Refactor vector_macros to consistently generate all vector types

Author: joriskleiber

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

@@ -32,6 +32,7 @@ pub trait FloatExt: private::Sealed + Copy {
     /// Check if `self` is within [`Self::CMP_EPSILON`] of `0.0`.
     fn is_zero_approx(self) -> bool;
 
+    /// Returns the floating-point modulus of `self` divided by `pmod`, wrapping equally in positive and negative.
     fn fposmod(self, pmod: Self) -> Self;
 
     /// Returns the multiple of `step` that is closest to `self`.

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

@@ -37,38 +37,25 @@ pub struct Vector2 {
     pub y: real,
 }
 
-impl Vector2 {
-    /// Vector with all components set to `0.0`.
-    pub const ZERO: Self = Self::splat(0.0);
-
-    /// Vector with all components set to `1.0`.
-    pub const ONE: Self = Self::splat(1.0);
-
-    /// Vector with all components set to `real::INFINITY`.
-    pub const INF: Self = Self::splat(real::INFINITY);
-
-    /// Unit vector in -X direction (right in 2D coordinate system).
-    pub const LEFT: Self = Self::new(-1.0, 0.0);
-
-    /// Unit vector in +X direction (right in 2D coordinate system).
-    pub const RIGHT: Self = Self::new(1.0, 0.0);
+impl_vector_operators!(Vector2, real, (x, y));
 
-    /// Unit vector in -Y direction (up in 2D coordinate system).
-    pub const UP: Self = Self::new(0.0, -1.0);
+impl_vector_consts!(Vector2, real);
+impl_float_vector_consts!(Vector2);
+impl_vector2x_consts!(Vector2, real);
 
-    /// Unit vector in +Y direction (down in 2D coordinate system).
-    pub const DOWN: Self = Self::new(0.0, 1.0);
+impl_vector_fns!(Vector2, real, (x, y));
+impl_float_vector_fns!(Vector2, (x, y));
+impl_vector2x_fns!(Vector2, real);
+impl_vector2_vector3_fns!(Vector2, (x, y));
 
-    /// Constructs a new `Vector2` from the given `x` and `y`.
-    pub const fn new(x: real, y: real) -> Self {
-        Self { x, y }
-    }
+// TODO: remove old impls
+impl_float_vector_glam_fns!(Vector2, real);
 
-    /// Constructs a new `Vector2` with both components set to `v`.
-    pub const fn splat(v: real) -> Self {
-        Self::new(v, v)
-    }
+// TODO: add functions only found in Vector2: angle, angle_to_point, from_angle, orthogonal, rotate
+impl Vector2 {}
 
+// TODO: remove old impls
+impl Vector2 {
     /// Constructs a new `Vector2` from a [`Vector2i`].
     pub const fn from_vector2i(v: Vector2i) -> Self {
         Self {
@@ -99,14 +86,6 @@ impl Vector2 {
         (to - self).angle()
     }
 
-    pub fn aspect(self) -> real {
-        self.x / self.y
-    }
-
-    pub fn bounce(self, normal: Self) -> Self {
-        -self.reflect(normal)
-    }
-
     pub fn ceil(self) -> Self {
         Self::from_glam(self.to_glam().ceil())
     }
@@ -131,10 +110,6 @@ impl Vector2 {
         (to - self).length()
     }
 
-    pub fn dot(self, other: Self) -> real {
-        self.to_glam().dot(other.to_glam())
-    }
-
     pub fn floor(self) -> Self {
         Self::from_glam(self.to_glam().floor())
     }
@@ -175,16 +150,6 @@ impl Vector2 {
         }
     }
 
-    pub fn move_toward(self, to: Self, delta: real) -> Self {
-        let vd = to - self;
-        let len = vd.length();
-        if len <= delta || len < real::CMP_EPSILON {
-            to
-        } else {
-            self + vd / len * delta
-        }
-    }
-
     pub fn orthogonal(self) -> Self {
         Self::new(self.y, -self.x)
     }
@@ -193,10 +158,6 @@ impl Vector2 {
         Self::from_glam(self.to_glam().project_onto(b.to_glam()))
     }
 
-    pub fn reflect(self, normal: Self) -> Self {
-        2.0 * normal * self.dot(normal) - self
-    }
-
     pub fn round(self) -> Self {
         Self::from_glam(self.to_glam().round())
     }
@@ -215,10 +176,6 @@ impl Vector2 {
         self.rotated(angle * weight) * (result_length / start_length)
     }
 
-    pub fn slide(self, normal: Self) -> Self {
-        self - normal * self.dot(normal)
-    }
-
     /// Returns the result of rotating this vector by `angle` (in radians).
     pub fn rotated(self, angle: real) -> Self {
         Self::from_glam(RAffine2::from_angle(angle).transform_vector2(self.to_glam()))
@@ -241,12 +198,6 @@ impl fmt::Display for Vector2 {
     }
 }
 
-impl_common_vector_fns!(Vector2, real);
-impl_float_vector_glam_fns!(Vector2, real);
-impl_float_vector_component_fns!(Vector2, real, (x, y));
-impl_vector_operators!(Vector2, real, (x, y));
-impl_from_tuple_for_vector2x!(Vector2, real);
-
 // SAFETY:
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.
 unsafe impl GodotFfi for Vector2 {
@@ -290,6 +241,13 @@ mod test {
         assert_eq_approx!(a.coord_max(b), Vector2::new(1.2, 5.6));
     }
 
+    #[test]
+    fn new_aspect() {
+        let v = Vector2::new(1.0, 2.0);
+
+        assert_eq_approx!(v.aspect(), 0.5);
+    }
+
     #[cfg(feature = "serde")]
     #[test]
     fn serde_roundtrip() {

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

@@ -6,12 +6,11 @@
  */
 
 use godot_ffi as sys;
-use std::cmp::Ordering;
 use sys::{ffi_methods, GodotFfi};
 
 use crate::builtin::math::{FloatExt, GlamConv, GlamType};
 use crate::builtin::meta::impl_godot_as_self;
-use crate::builtin::{real, RVec2, Vector2, Vector2Axis};
+use crate::builtin::{real, RVec2, Vector2};
 
 use std::fmt;
 
@@ -35,58 +34,21 @@ pub struct Vector2i {
     pub y: i32,
 }
 
-impl Vector2i {
-    /// Vector with all components set to `0`.
-    pub const ZERO: Self = Self::splat(0);
-
-    /// Vector with all components set to `1`.
-    pub const ONE: Self = Self::splat(1);
-
-    /// Unit vector in -X direction (right in 2D coordinate system).
-    pub const LEFT: Self = Self::new(-1, 0);
-
-    /// Unit vector in +X direction (right in 2D coordinate system).
-    pub const RIGHT: Self = Self::new(1, 0);
-
-    /// Unit vector in -Y direction (up in 2D coordinate system).
-    pub const UP: Self = Self::new(0, -1);
-
-    /// Unit vector in +Y direction (down in 2D coordinate system).
-    pub const DOWN: Self = Self::new(0, 1);
-
-    /// Constructs a new `Vector2i` from the given `x` and `y`.
-    pub const fn new(x: i32, y: i32) -> Self {
-        Self { x, y }
-    }
-
-    /// Aspect ratio: x / y, as a `real` value.
-    pub fn aspect(self) -> real {
-        self.x as real / self.y as real
-    }
+impl_vector_operators!(Vector2i, i32, (x, y));
 
-    /// Axis of the vector's highest value. [`None`] if components are equal.
-    pub fn max_axis(self) -> Option<Vector2Axis> {
-        match self.x.cmp(&self.y) {
-            Ordering::Less => Some(Vector2Axis::Y),
-            Ordering::Equal => None,
-            Ordering::Greater => Some(Vector2Axis::X),
-        }
-    }
+impl_vector_consts!(Vector2i, i32);
+impl_integer_vector_consts!(Vector2i);
+impl_vector2x_consts!(Vector2i, i32);
 
-    /// Axis of the vector's highest value. [`None`] if components are equal.
-    pub fn min_axis(self) -> Option<Vector2Axis> {
-        match self.x.cmp(&self.y) {
-            Ordering::Less => Some(Vector2Axis::X),
-            Ordering::Equal => None,
-            Ordering::Greater => Some(Vector2Axis::Y),
-        }
-    }
+impl_vector_fns!(Vector2i, i32, (x, y));
+impl_vector2x_fns!(Vector2i, i32);
 
-    /// Constructs a new `Vector2i` with both components set to `v`.
-    pub const fn splat(v: i32) -> Self {
-        Self::new(v, v)
-    }
+// TODO: remove old impls
+impl_integer_vector_glam_fns!(Vector2i, real);
+impl_integer_vector_component_fns!(Vector2i, real, (x, y));
 
+// TODO: remove old impls
+impl Vector2i {
     /// Constructs a new `Vector2i` from a [`Vector2`]. The floating point coordinates will be truncated.
     pub const fn from_vector2(v: Vector2) -> Self {
         Self {
@@ -122,12 +84,6 @@ impl fmt::Display for Vector2i {
     }
 }
 
-impl_common_vector_fns!(Vector2i, i32);
-impl_integer_vector_glam_fns!(Vector2i, real);
-impl_integer_vector_component_fns!(Vector2i, real, (x, y));
-impl_vector_operators!(Vector2i, i32, (x, y));
-impl_from_tuple_for_vector2x!(Vector2i, i32);
-
 // SAFETY:
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.
 unsafe impl GodotFfi for Vector2i {
@@ -158,6 +114,8 @@ impl GlamConv for Vector2i {
 
 #[cfg(test)]
 mod test {
+    use crate::builtin::Vector2Axis;
+
     use super::*;
 
     #[test]
@@ -179,13 +137,13 @@ mod test {
 
     #[test]
     fn axis_min_max() {
-        assert_eq!(Vector2i::new(10, 5).max_axis(), Some(Vector2Axis::X));
-        assert_eq!(Vector2i::new(5, 10).max_axis(), Some(Vector2Axis::Y));
+        assert_eq!(Vector2i::new(10, 5).max_axis(), Vector2Axis::X);
+        assert_eq!(Vector2i::new(5, 10).max_axis(), Vector2Axis::Y);
 
-        assert_eq!(Vector2i::new(-5, 5).min_axis(), Some(Vector2Axis::X));
-        assert_eq!(Vector2i::new(5, -5).min_axis(), Some(Vector2Axis::Y));
+        assert_eq!(Vector2i::new(-5, 5).min_axis(), Vector2Axis::X);
+        assert_eq!(Vector2i::new(5, -5).min_axis(), Vector2Axis::Y);
 
-        assert_eq!(Vector2i::new(15, 15).max_axis(), None);
-        assert_eq!(Vector2i::new(15, 15).min_axis(), None);
+        assert_eq!(Vector2i::new(15, 15).max_axis(), Vector2Axis::X);
+        assert_eq!(Vector2i::new(15, 15).min_axis(), Vector2Axis::Y);
     }
 }