Vector conversion functions between int and float

Author: Bromeon

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

@@ -164,7 +164,7 @@ impl Vector2 {
     }
 }
 
-impl_float_vector_fns!(Vector2, (x, y));
+impl_float_vector_fns!(Vector2, Vector2i, (x, y));
 impl_vector2x_fns!(Vector2, Vector3, real);
 impl_vector2_vector3_fns!(Vector2, (x, y));
 

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

@@ -65,7 +65,7 @@ impl Vector2i {
 
 /// # Specialized `Vector2i` functions
 impl Vector2i {
-    inline_impl_integer_vector_fns!(x, y);
+    inline_impl_integer_vector_fns!(Vector2, x, y);
 
     /// Constructs a new `Vector2i` from a [`Vector2`]. The floating point coordinates will be truncated.
     #[inline]

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

@@ -231,7 +231,7 @@ impl Vector3 {
     }
 }
 
-impl_float_vector_fns!(Vector3, (x, y, z));
+impl_float_vector_fns!(Vector3, Vector3i, (x, y, z));
 impl_vector3x_fns!(Vector3, Vector2, real);
 impl_vector2_vector3_fns!(Vector3, (x, y, z));
 impl_vector3_vector4_fns!(Vector3, (x, y, z));

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

@@ -80,7 +80,7 @@ impl Vector3i {
         }
     }
 
-    inline_impl_integer_vector_fns!(x, y, z);
+    inline_impl_integer_vector_fns!(Vector3, x, y, z);
 
     /// Converts `self` to the corresponding [`real`] `glam` type.
     #[doc(hidden)]

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

@@ -89,7 +89,7 @@ impl Vector4 {
     }
 }
 
-impl_float_vector_fns!(Vector4, (x, y, z, w));
+impl_float_vector_fns!(Vector4, Vector4i, (x, y, z, w));
 impl_vector4x_fns!(Vector4, real);
 impl_vector3_vector4_fns!(Vector4, (x, y, z, w));
 

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

@@ -71,7 +71,7 @@ impl_vector_fns!(Vector4i, glam::IVec4, i32, (x, y, z, w));
 
 /// # Specialized `Vector4i` functions
 impl Vector4i {
-    inline_impl_integer_vector_fns!(x, y, z, w);
+    inline_impl_integer_vector_fns!(Vector4, x, y, z, w);
 
     /// Constructs a new `Vector4i` from a [`Vector4`]. The floating point coordinates will be
     /// truncated.

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

@@ -532,6 +532,8 @@ pub(super) fn snap_one(mut value: i32, step: i32) -> i32 {
 /// Implements functions that are present only on integer vectors.
 macro_rules! inline_impl_integer_vector_fns {
     (
+        // Name of the float-equivalent vector type.
+        $VectorFloat:ty,
         // Names of the components, for example `x, y`.
         $($comp:ident),*
     ) => {
@@ -551,20 +553,38 @@ macro_rules! inline_impl_integer_vector_fns {
                 ),*
             )
         }
+
+        /// Converts to a vector with floating-point [`real`](type.real.html) components, using `as` casts.
+        pub fn to_float_vector(self) -> $VectorFloat {
+            <$VectorFloat>::new( $(self.$comp as real),* )
+        }
     };
 }
 
 macro_rules! impl_float_vector_fns {
     (
         // Name of the vector type.
         $Vector:ty,
+        // Name of the integer-equivalent vector type.
+        $VectorInt:ty,
         // Names of the components, with parentheses, for example `(x, y)`.
         ($($comp:ident),*)
     ) => {
         /// # Float-specific functions
         ///
         /// The following methods are only available on floating-point vectors.
         impl $Vector {
+            /// Converts to a vector with integer components, using `as` casts.
+            pub fn to_int_vector(self) -> $VectorInt {
+                <$VectorInt>::new( $(self.$comp as i32),* )
+            }
+
+            /// Returns a new vector with all components rounded down (towards negative infinity).
+            #[inline]
+            pub fn floor(self) -> Self {
+                Self::from_glam(self.to_glam().floor())
+            }
+
             /// Returns a new vector with all components rounded up (towards positive infinity).
             #[inline]
             pub fn ceil(self) -> Self {
@@ -649,12 +669,6 @@ macro_rules! impl_float_vector_fns {
                 self.to_glam().dot(with.to_glam())
             }
 
-            /// Returns a new vector with all components rounded down (towards negative infinity).
-            #[inline]
-            pub fn floor(self) -> Self {
-                Self::from_glam(self.to_glam().floor())
-            }
-
             /// Returns true if each component of this vector is finite.
             #[inline]
             pub fn is_finite(self) -> bool {