Vector/Rect2 conversion functions between int and float

Deprecate from_rect2[i], from_vectorX[i] constructors.

Author: Bromeon

godot-core/src/builtin/rect2.rs

@@ -63,14 +63,20 @@ impl Rect2 {
         }
     }
 
-    /// Create a new `Rect2` from a `Rect2i`, using `as` for `i32` to `real` conversions.
-    ///
-    /// _Godot equivalent: `Rect2(Rect2i from)`_
+    #[deprecated = "Moved to `Rect2i::cast_float()`"]
     #[inline]
     pub const fn from_rect2i(rect: Rect2i) -> Self {
-        Self {
-            position: Vector2::from_vector2i(rect.position),
-            size: Vector2::from_vector2i(rect.size),
+        rect.cast_float()
+    }
+
+    /// Create a new `Rect2i` from a `Rect2`, using `as` for `real` to `i32` conversions.
+    ///
+    /// _Godot equivalent: `Rect2i(Rect2 from)`_
+    #[inline]
+    pub const fn cast_int(self) -> Rect2i {
+        Rect2i {
+            position: self.position.cast_int(),
+            size: self.size.cast_int(),
         }
     }
 

godot-core/src/builtin/rect2i.rs

@@ -60,17 +60,6 @@ impl Rect2i {
         }
     }
 
-    /// Create a new `Rect2i` from a `Rect2`, using `as` for `real` to `i32` conversions.
-    ///
-    /// _Godot equivalent: `Rect2i(Rect2 from)`_
-    #[inline]
-    pub const fn from_rect2(rect: Rect2) -> Self {
-        Self {
-            position: Vector2i::from_vector2(rect.position),
-            size: Vector2i::from_vector2(rect.size),
-        }
-    }
-
     /// Create a new `Rect2i` with the first corner at `position` and the opposite corner at `end`.
     #[inline]
     pub fn from_corners(position: Vector2i, end: Vector2i) -> Self {
@@ -80,6 +69,23 @@ impl Rect2i {
         }
     }
 
+    #[deprecated = "Moved to `Rect2::cast_int()`"]
+    #[inline]
+    pub const fn from_rect2(rect: Rect2) -> Self {
+        rect.cast_int()
+    }
+
+    /// Create a new `Rect2` from a `Rect2i`, using `as` for `i32` to `real` conversions.
+    ///
+    /// _Godot equivalent: `Rect2(Rect2i from)`_
+    #[inline]
+    pub const fn cast_float(self) -> Rect2 {
+        Rect2 {
+            position: self.position.cast_float(),
+            size: self.size.cast_float(),
+        }
+    }
+
     /// The end of the `Rect2i` calculated as `position + size`.
     ///
     /// _Godot equivalent: `Rect2i.size` property_

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

@@ -69,13 +69,10 @@ impl_vector_fns!(Vector2, RVec2, real, (x, y));
 
 /// # Specialized `Vector2` functions
 impl Vector2 {
-    /// Constructs a new `Vector2` from a [`Vector2i`].
+    #[deprecated = "Moved to `Vector2i::cast_float()`"]
     #[inline]
     pub const fn from_vector2i(v: Vector2i) -> Self {
-        Self {
-            x: v.x as real,
-            y: v.y as real,
-        }
+        v.cast_float()
     }
 
     /// Returns this vector's angle with respect to the positive X axis, or `(1.0, 0.0)` vector, in radians.
@@ -164,7 +161,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,15 +65,12 @@ 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.
+    #[deprecated = "Moved to `Vector2::cast_int()`"]
     #[inline]
     pub const fn from_vector2(v: Vector2) -> Self {
-        Self {
-            x: v.x as i32,
-            y: v.y as i32,
-        }
+        v.cast_int()
     }
 
     /// Converts `self` to the corresponding [`real`] `glam` type.

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

@@ -67,12 +67,7 @@ impl Vector3 {
     impl_vector_consts!(real);
     impl_float_vector_consts!();
     impl_vector3x_consts!(real);
-}
-
-impl_vector_fns!(Vector3, RVec3, real, (x, y, z));
 
-/// # Specialized `Vector3` functions
-impl Vector3 {
     /// Unit vector pointing towards the left side of imported 3D assets.
     pub const MODEL_LEFT: Self = Self::new(1.0, 0.0, 0.0);
 
@@ -90,15 +85,16 @@ impl Vector3 {
 
     /// Unit vector pointing towards the rear side (back) of imported 3D assets.
     pub const MODEL_REAR: Self = Self::new(0.0, 0.0, -1.0);
+}
 
-    /// Constructs a new `Vector3` from a [`Vector3i`].
+impl_vector_fns!(Vector3, RVec3, real, (x, y, z));
+
+/// # Specialized `Vector3` functions
+impl Vector3 {
+    #[deprecated = "Moved to `Vector3i::cast_float()`"]
     #[inline]
     pub const fn from_vector3i(v: Vector3i) -> Self {
-        Self {
-            x: v.x as real,
-            y: v.y as real,
-            z: v.z as real,
-        }
+        v.cast_float()
     }
 
     #[doc(hidden)]
@@ -231,7 +227,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

@@ -70,17 +70,13 @@ impl_vector_fns!(Vector3i, glam::IVec3, i32, (x, y, z));
 
 /// # Specialized `Vector3i` functions
 impl Vector3i {
-    /// Constructs a new `Vector3i` from a [`Vector3`]. The floating point coordinates will be truncated.
+    #[deprecated = "Moved to `Vector3::cast_int()`"]
     #[inline]
     pub const fn from_vector3(v: Vector3) -> Self {
-        Self {
-            x: v.x as i32,
-            y: v.y as i32,
-            z: v.z as i32,
-        }
+        v.cast_int()
     }
 
-    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

@@ -72,14 +72,9 @@ impl_vector_fns!(Vector4, RVec4, real, (x, y, z, w));
 
 /// # Specialized `Vector4` functions
 impl Vector4 {
-    /// Constructs a new `Vector4` from a [`Vector4i`][crate::builtin::Vector4i].
+    #[deprecated = "Moved to `Vector4i::cast_float()`"]
     pub const fn from_vector4i(v: Vector4i) -> Self {
-        Self {
-            x: v.x as real,
-            y: v.y as real,
-            z: v.z as real,
-            w: v.w as real,
-        }
+        v.cast_float()
     }
 
     #[doc(hidden)]
@@ -89,7 +84,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,18 +71,12 @@ 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.
+    #[deprecated = "Moved to `Vector4::cast_int()`"]
     #[inline]
     pub const fn from_vector4(v: Vector4) -> Self {
-        Self {
-            x: v.x as i32,
-            y: v.y as i32,
-            z: v.z as i32,
-            w: v.w as i32,
-        }
+        v.cast_int()
     }
 
     /// Converts `self` to the corresponding [`real`] `glam` type.

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),*
     ) => {
@@ -542,6 +544,7 @@ macro_rules! inline_impl_integer_vector_fns {
         /// On under- or overflow:
         /// - If any component of `self` is [`i32::MIN`] while the same component on `step` is `-1`.
         /// - If any component of `self` plus half of the same component of `step` is not in range on [`i32`].
+        #[inline]
         pub fn snapped(self, step: Self) -> Self {
             use crate::builtin::vectors::vector_macros::snap_one;
 
@@ -551,20 +554,39 @@ macro_rules! inline_impl_integer_vector_fns {
                 ),*
             )
         }
+
+        /// Converts to a vector with floating-point [`real`](type.real.html) components, using `as` casts.
+        #[inline]
+        pub const fn cast_float(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 const fn cast_int(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 +671,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 {