glam: Vec2::angle_between() deprecated -> angle_to()

Author: Bromeon

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

@@ -77,6 +77,21 @@ impl Vector2 {
         v.cast_float()
     }
 
+    /// Creates a unit Vector2 rotated to the given `angle` in radians. This is equivalent to doing `Vector2::new(angle.cos(), angle.sin())`
+    /// or `Vector2::RIGHT.rotated(angle)`.
+    ///
+    /// ```no_run
+    /// use godot::prelude::*;
+    ///
+    /// let a = Vector2::from_angle(0.0);                       // (1.0, 0.0)
+    /// let b = Vector2::new(1.0, 0.0).angle();                 // 0.0
+    /// let c = Vector2::from_angle(real_consts::PI / 2.0);     // (0.0, 1.0)
+    /// ```
+    #[inline]
+    pub fn from_angle(angle: real) -> Self {
+        Self::from_glam(RVec2::from_angle(angle))
+    }
+
     /// Returns this vector's angle with respect to the positive X axis, or `(1.0, 0.0)` vector, in radians.
     ///
     /// For example, `Vector2::RIGHT.angle()` will return zero, `Vector2::DOWN.angle()` will return `PI / 2` (a quarter turn, or 90 degrees),
@@ -90,6 +105,14 @@ impl Vector2 {
         self.y.atan2(self.x)
     }
 
+    /// Returns the **signed** angle between `self` and the given vector, as radians in `[-π, +π]`.
+    ///
+    /// Note that behavior is different from 3D [`Vector3::angle_to()`] which returns the **unsigned** angle.
+    #[inline]
+    pub fn angle_to(self, to: Self) -> real {
+        self.glam2(&to, |a, b| a.angle_to(b))
+    }
+
     /// Returns the angle to the given vector, in radians.
     ///
     /// [Illustration of the returned angle.](https://raw.githubusercontent.com/godotengine/godot-docs/master/img/vector2_angle_to.png)
@@ -111,21 +134,6 @@ impl Vector2 {
         self.to_glam().perp_dot(with.to_glam())
     }
 
-    /// Creates a unit Vector2 rotated to the given `angle` in radians. This is equivalent to doing `Vector2::new(angle.cos(), angle.sin())`
-    /// or `Vector2::RIGHT.rotated(angle)`.
-    ///
-    /// ```no_run
-    /// use godot::prelude::*;
-    ///
-    /// let a = Vector2::from_angle(0.0);                       // (1.0, 0.0)
-    /// let b = Vector2::new(1.0, 0.0).angle();                 // 0.0
-    /// let c = Vector2::from_angle(real_consts::PI / 2.0);     // (0.0, 1.0)
-    /// ```
-    #[inline]
-    pub fn from_angle(angle: real) -> Self {
-        Self::from_glam(RVec2::from_angle(angle))
-    }
-
     /// Returns a perpendicular vector rotated 90 degrees counter-clockwise compared to the original, with the same length.
     #[inline]
     pub fn orthogonal(self) -> Self {

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

@@ -180,8 +180,20 @@ impl Vector3 {
         Basis::from_axis_angle(axis, angle) * self
     }
 
-    /// Returns the signed angle to the given vector, in radians. The sign of the angle is positive in a counter-clockwise direction and
-    /// negative in a clockwise direction when viewed from the side specified by the `axis`.
+    /// Returns the **unsigned** angle between `self` and the given vector, as radians in `[0, +π]`.
+    ///
+    /// Note that behavior is different from 2D [`Vector2::angle_to()`], which returns the **signed** angle.
+    #[inline]
+    pub fn angle_to(self, to: Self) -> real {
+        self.glam2(&to, |a, b| a.angle_between(b))
+    }
+
+    /// Returns the signed angle to the given vector, as radians in `[-π, +π]`.
+    ///
+    /// The sign of the angle is positive in a counter-clockwise direction and negative in a clockwise direction, when viewed from
+    /// the side specified by the `axis`.
+    ///
+    /// For unsigned angles, use [`Vector3::angle_to()`].
     #[inline]
     pub fn signed_angle_to(self, to: Self, axis: Self) -> real {
         let cross_to = self.cross(to);

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

@@ -1009,12 +1009,6 @@ macro_rules! impl_vector2_vector3_fns {
         /// # 2D and 3D functions
         /// The following methods are available on both 2D and 3D float vectors.
         impl $Vector {
-            /// Returns the angle to the given vector, in radians.
-            #[inline]
-            pub fn angle_to(self, to: Self) -> real {
-                self.glam2(&to, |a, b| a.angle_between(b))
-            }
-
            /// Returns the derivative at the given `t` on the [Bézier](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
            /// curve defined by this vector and the given `control_1`, `control_2`, and `end` points.
            #[inline]