Fix some vector refactor errors

Author: joriskleiber

godot-core/src/builtin/aabb.rs

@@ -189,18 +189,18 @@ impl Aabb {
 
     /// Returns the normalized longest axis of the AABB.
     #[inline]
-    pub fn longest_axis(&self) -> Vector3 {
-        match self.longest_axis_index() {
+    pub fn longest_axis(&self) -> Option<Vector3> {
+        self.longest_axis_index().map(|axis| match axis {
             Vector3Axis::X => Vector3::RIGHT,
             Vector3Axis::Y => Vector3::UP,
             Vector3Axis::Z => Vector3::BACK,
-        }
+        })
     }
 
     /// Returns the index of the longest axis of the AABB (according to Vector3's AXIS_* constants).
     #[inline]
-    pub fn longest_axis_index(&self) -> Vector3Axis {
-        self.size.max_axis().unwrap_or(Vector3Axis::X)
+    pub fn longest_axis_index(&self) -> Option<Vector3Axis> {
+        self.size.max_axis()
     }
 
     /// Returns the scalar length of the longest axis of the AABB.
@@ -211,18 +211,18 @@ impl Aabb {
 
     /// Returns the normalized shortest axis of the AABB.
     #[inline]
-    pub fn shortest_axis(&self) -> Vector3 {
-        match self.shortest_axis_index() {
+    pub fn shortest_axis(&self) -> Option<Vector3> {
+        self.shortest_axis_index().map(|axis| match axis {
             Vector3Axis::X => Vector3::RIGHT,
             Vector3Axis::Y => Vector3::UP,
             Vector3Axis::Z => Vector3::BACK,
-        }
+        })
     }
 
     /// Returns the index of the shortest axis of the AABB (according to Vector3::AXIS* enum).
     #[inline]
-    pub fn shortest_axis_index(&self) -> Vector3Axis {
-        self.size.min_axis().unwrap_or(Vector3Axis::Z)
+    pub fn shortest_axis_index(&self) -> Option<Vector3Axis> {
+        self.size.min_axis()
     }
 
     /// Returns the scalar length of the shortest axis of the AABB.
@@ -436,12 +436,12 @@ mod test {
             size: Vector3::new(4.0, 6.0, 8.0),
         };
 
-        assert_eq!(aabb.shortest_axis(), Vector3::RIGHT);
-        assert_eq!(aabb.longest_axis(), Vector3::BACK);
+        assert_eq!(aabb.shortest_axis(), Some(Vector3::RIGHT));
+        assert_eq!(aabb.longest_axis(), Some(Vector3::BACK));
         assert_eq!(aabb.shortest_axis_size(), 4.0);
         assert_eq!(aabb.longest_axis_size(), 8.0);
-        assert_eq!(aabb.shortest_axis_index(), Vector3Axis::X);
-        assert_eq!(aabb.longest_axis_index(), Vector3Axis::Z);
+        assert_eq!(aabb.shortest_axis_index(), Some(Vector3Axis::X));
+        assert_eq!(aabb.longest_axis_index(), Some(Vector3Axis::Z));
     }
 
     #[test]

godot-core/src/builtin/math/glam_helpers.rs

@@ -21,12 +21,10 @@ use crate::builtin::real;
 pub(crate) trait GlamConv {
     type Glam: GlamType<Mapped = Self>;
 
-    #[inline]
     fn to_glam(&self) -> Self::Glam {
         Self::Glam::from_front(self)
     }
 
-    #[inline]
     fn glam<F, R>(&self, unary_fn: F) -> R::Mapped
     where
         R: GlamType,
@@ -38,7 +36,6 @@ pub(crate) trait GlamConv {
         result.to_front()
     }
 
-    #[inline]
     fn glam2<F, P, R>(&self, rhs: &P, binary_fn: F) -> R::Mapped
     where
         P: GlamConv,

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

@@ -102,11 +102,10 @@ impl Vector2 {
     ///
     /// ```no_run
     /// use godot::prelude::*;
-    /// use std::f32::consts::PI;
     ///
-    /// 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(PI / 2.0);  // (0.0, 1.0)
+    /// 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 {

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

@@ -59,7 +59,7 @@ impl Vector3 {
     pub const MODEL_RIGHT: Self = Self::new(-1.0, 0.0, 0.0);
 
     /// Unit vector pointing towards the top side (up) of imported 3D assets.
-    pub const MODEL_UP: Self = Self::new(0.0, 1.0, 0.0);
+    pub const MODEL_TOP: Self = Self::new(0.0, 1.0, 0.0);
 
     /// Unit vector pointing towards the bottom side (down) of imported 3D assets.
     pub const MODEL_BOTTOM: Self = Self::new(0.0, -1.0, 0.0);
@@ -120,7 +120,7 @@ impl Vector3 {
     /// If vector is not normalized.
     #[inline]
     pub fn octahedron_encode(self) -> Vector2 {
-        assert!(self.is_normalized());
+        assert!(self.is_normalized(), "vector is not normalized!");
 
         let mut n = self;
         n /= n.x.abs() + n.y.abs() + n.z.abs();
@@ -156,7 +156,7 @@ impl Vector3 {
     /// If `axis` is not normalized.
     #[inline]
     pub fn rotated(self, axis: Self, angle: real) -> Self {
-        assert!(axis.is_normalized());
+        assert!(axis.is_normalized(), "axis is not normalized!");
         Basis::from_axis_angle(axis, angle) * self
     }
 

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

@@ -289,10 +289,10 @@ macro_rules! impl_integer_vector_consts {
         $Vector:ty
     ) => {
         impl $Vector {
-            /// Min vector, a vector with all components equal to [`i32::MIN`]. Can be used as a negative integer equivalent of [`Vector2::INF`].
+            /// Min vector, a vector with all components equal to [`i32::MIN`]. Can be used as a negative integer equivalent of `real::INF`.
             pub const MIN: Self = Self::splat(i32::MIN);
 
-            /// Max vector, a vector with all components equal to [`i32::MAX`]. Can be used as an integer equivalent of [`Vector2::INF`].
+            /// Max vector, a vector with all components equal to [`i32::MAX`]. Can be used as an integer equivalent of `real::INF`.
             pub const MAX: Self = Self::splat(i32::MAX);
         }
     };
@@ -402,8 +402,8 @@ macro_rules! impl_vector_fns {
 
             /// Returns a new vector with all components clamped between the components of `min` and `max`.
             ///
-            /// Panics
-            /// Panics if `min` > `max`, `min` is NaN, or `max` is NaN.
+            /// # Panics
+            /// If `min` > `max`, `min` is NaN, or `max` is NaN.
             #[inline]
             pub fn clamp(self, min: Self, max: Self) -> Self {
                 Self::from_glam(self.to_glam().clamp(min.to_glam(), max.to_glam()))
@@ -462,7 +462,9 @@ macro_rules! impl_float_vector_fns {
             }
 
             /// Performs a cubic interpolation between this vector and `b` using `pre_a` and `post_b` as handles,
-            /// and returns the result at position `weight`. `weight` is on the range of 0.0 to 1.0, representing the amount of interpolation.
+            /// and returns the result at position `weight`.
+            ///
+            /// `weight` is on the range of 0.0 to 1.0, representing the amount of interpolation.
             #[inline]
             pub fn cubic_interpolate(self, b: Self, pre_a: Self, post_b: Self, weight: real) -> Self {
                 Self::new(
@@ -473,7 +475,9 @@ macro_rules! impl_float_vector_fns {
             }
 
             /// Performs a cubic interpolation between this vector and `b` using `pre_a` and `post_b` as handles,
-            /// and returns the result at position `weight`. `weight` is on the range of 0.0 to 1.0, representing the amount of interpolation.
+            /// and returns the result at position `weight`.
+            ///
+            /// `weight` is on the range of 0.0 to 1.0, representing the amount of interpolation.
             /// It can perform smoother interpolation than [`Self::cubic_interpolate`] by the time values.
             #[inline]
             #[allow(clippy::too_many_arguments)]
@@ -496,7 +500,9 @@ macro_rules! impl_float_vector_fns {
                 )
             }
 
-            /// Returns the normalized vector pointing from this vector to `to`. This is equivalent to using `(b - a).normalized()`.
+            /// Returns the normalized vector pointing from this vector to `to`.
+            ///
+            /// This is equivalent to using `(b - a).normalized()`.
             #[inline]
             pub fn direction_to(self, to: Self) -> Self {
                 (to - self).normalized()
@@ -541,13 +547,15 @@ macro_rules! impl_float_vector_fns {
             }
 
             /// Returns `true` if this vector's values are approximately zero.
-            /// This method is faster than using [`Self::is_equal_approx`] with one value as a zero vector.
+            ///
+            /// This method is faster than using `approx_eq()` with one value as a zero vector.
             #[inline]
             pub fn is_zero_approx(self) -> bool {
                 $( self.$comp.is_zero_approx() )&&*
             }
 
             /// Returns the result of the linear interpolation between this vector and `to` by amount `weight`.
+            ///
             /// `weight` is on the range of `0.0` to `1.0`, representing the amount of interpolation.
             #[inline]
             pub fn lerp(self, other: Self, weight: real) -> Self {
@@ -559,19 +567,14 @@ macro_rules! impl_float_vector_fns {
             /// Returns the vector scaled to unit length. Equivalent to `self / self.length()`. See
             /// also `is_normalized()`.
             ///
-            /// If the vector is zero, the result is also zero.
+            /// # Panics
+            /// If called on a zero vector.
             #[inline]
             pub fn normalized(self) -> Self {
-                // Copy Godot's implementation since it's faster than using glam's normalize_or_zero().
-                if self == Self::ZERO {
-                    return self;
-                }
-
-                let l = self.length();
+                assert_ne!(self, Self::ZERO, "normalized() called on zero vector");
 
-                Self::new(
-                    $( self.$comp / l ),*
-                )
+                // Copy Godot's implementation since it's faster than using glam's normalize_or_zero().
+                self / self.length()
             }
 
             /// Returns a vector composed of the [`FloatExt::fposmod`] of this vector's components and `pmod`.
@@ -612,7 +615,7 @@ macro_rules! impl_float_vector_fns {
         impl $crate::builtin::math::ApproxEq for $Vector {
             /// Returns `true` if this vector and `to` are approximately equal.
             #[inline]
-            #[doc(alias = "is_approx_eq")]
+            #[doc(alias = "is_equal_approx")]
             fn approx_eq(&self, other: &Self) -> bool {
                 $( self.$comp.approx_eq(&other.$comp) )&&*
             }
@@ -857,9 +860,13 @@ macro_rules! impl_vector2_vector3_fns {
             }
 
             /// Returns a new vector "bounced off" from a plane defined by the given normal.
+            ///
+            /// # Panics
+            /// If `n` is not normalized.
             #[inline]
-            pub fn bounce(self, normal: Self) -> Self {
-                -self.reflect(normal)
+            pub fn bounce(self, n: Self) -> Self {
+                assert!(n.is_normalized(), "n is not normalized!");
+                -self.reflect(n)
             }
 
             /// Returns the vector with a maximum length by limiting its length to `length`.
@@ -884,14 +891,22 @@ macro_rules! impl_vector2_vector3_fns {
             }
 
             /// Returns the result of reflecting the vector defined by the given direction vector `n`.
+            ///
+            /// # Panics
+            /// If `n` is not normalized.
             #[inline]
             pub fn reflect(self, n: Self) -> Self {
+                assert!(n.is_normalized(), "n is not normalized!");
                 2.0 * n * self.dot(n) - self
             }
 
             /// Returns a new vector slid along a plane defined by the given normal.
+            ///
+            /// # Panics
+            /// If `n` is not normalized.
             #[inline]
             pub fn slide(self, n: Self) -> Self {
+                assert!(n.is_normalized(), "n is not normalized!");
                 self - n * self.dot(n)
             }
         }
@@ -911,9 +926,7 @@ macro_rules! impl_vector3_vector4_fns {
             #[inline]
             #[doc(alias = "inverse")]
             pub fn recip(self) -> Self {
-                Self::new(
-                    $( 1.0 / self.$comp ),*
-                )
+                Self::from_glam(self.to_glam().recip())
             }
         }
     };