Add missing integer vector methods

Author: kulkalkul

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

@@ -13,7 +13,6 @@ pub use approx_eq::ApproxEq;
 pub use float::FloatExt;
 
 // Internal glam re-exports
-pub(crate) use glam::{IVec2, IVec3, IVec4};
 pub(crate) use glam_helpers::*;
 
 #[cfg(test)]

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

@@ -5,10 +5,11 @@
  */
 
 use godot_ffi as sys;
+use std::cmp::Ordering;
 use sys::{ffi_methods, GodotFfi};
 
-use crate::builtin::math::{GlamConv, GlamType, IVec2};
-use crate::builtin::Vector2;
+use crate::builtin::math::{FloatExt, GlamConv, GlamType};
+use crate::builtin::{real, RVec2, Vector2, Vector2Axis};
 
 use std::fmt;
 
@@ -56,6 +57,29 @@ impl Vector2i {
         Self { x, y }
     }
 
+    ///Aspect ratio: x / y, as a `real` value.
+    pub fn aspect(self) -> real {
+        self.x as real / self.y as real
+    }
+
+    /// 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),
+        }
+    }
+
+    /// 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),
+        }
+    }
+
     /// Constructs a new `Vector2i` with both components set to `v`.
     pub const fn splat(v: i32) -> Self {
         Self::new(v, v)
@@ -70,13 +94,18 @@ impl Vector2i {
     }
 
     /// Converts the corresponding `glam` type to `Self`.
-    fn from_glam(v: IVec2) -> Self {
+    fn from_glam(v: glam::IVec2) -> Self {
         Self::new(v.x, v.y)
     }
 
     /// Converts `self` to the corresponding `glam` type.
     fn to_glam(self) -> glam::IVec2 {
-        IVec2::new(self.x, self.y)
+        glam::IVec2::new(self.x, self.y)
+    }
+
+    /// Converts `self` to the corresponding [`real`] `glam` type.
+    fn to_glam_real(self) -> RVec2 {
+        RVec2::new(self.x as real, self.y as real)
     }
 
     pub fn coords(&self) -> (i32, i32) {
@@ -92,6 +121,8 @@ 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);
 
@@ -101,20 +132,20 @@ unsafe impl GodotFfi for Vector2i {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 
-impl GlamType for IVec2 {
+impl GlamType for glam::IVec2 {
     type Mapped = Vector2i;
 
     fn to_front(&self) -> Self::Mapped {
         Vector2i::new(self.x, self.y)
     }
 
     fn from_front(mapped: &Self::Mapped) -> Self {
-        IVec2::new(mapped.x, mapped.y)
+        glam::IVec2::new(mapped.x, mapped.y)
     }
 }
 
 impl GlamConv for Vector2i {
-    type Glam = IVec2;
+    type Glam = glam::IVec2;
 }
 
 #[cfg(test)]
@@ -137,4 +168,25 @@ mod test {
 
         crate::builtin::test_utils::roundtrip(&vector, expected_json);
     }
+
+    #[test]
+    fn axis_min_max() {
+        let x_max = Vector2i::new(10, 5);
+        let y_max = Vector2i::new(5, 10);
+
+        let x_min = Vector2i::new(-5, 5);
+        let y_min = Vector2i::new(5, -5);
+
+        let max_eq = Vector2i::new(15, 15);
+        let min_eq = Vector2i::new(15, 15);
+
+        assert_eq!(x_max.max_axis(), Some(Vector2Axis::X));
+        assert_eq!(y_max.max_axis(), Some(Vector2Axis::Y));
+
+        assert_eq!(x_min.min_axis(), Some(Vector2Axis::X));
+        assert_eq!(y_min.min_axis(), Some(Vector2Axis::Y));
+
+        assert_eq!(max_eq.max_axis(), None);
+        assert_eq!(min_eq.min_axis(), None);
+    }
 }

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

@@ -4,13 +4,14 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
+use std::cmp::Ordering;
 use std::fmt;
 
 use godot_ffi as sys;
 use sys::{ffi_methods, GodotFfi};
 
-use crate::builtin::math::{GlamConv, GlamType, IVec3};
-use crate::builtin::Vector3;
+use crate::builtin::math::{FloatExt, GlamConv, GlamType};
+use crate::builtin::{real, RVec3, Vector3, Vector3Axis};
 
 /// Vector used for 3D math using integer coordinates.
 ///
@@ -65,6 +66,50 @@ impl Vector3i {
         Self { x, y, z }
     }
 
+    /// Axis of the vector's highest value. [`None`] if at least two components are equal.
+    pub fn max_axis(self) -> Option<Vector3Axis> {
+        use Vector3Axis::*;
+
+        match self.x.cmp(&self.y) {
+            Ordering::Less => match self.y.cmp(&self.z) {
+                Ordering::Less => Some(Z),
+                Ordering::Equal => None,
+                Ordering::Greater => Some(Y),
+            },
+            Ordering::Equal => match self.x.cmp(&self.z) {
+                Ordering::Less => Some(Z),
+                _ => None,
+            },
+            Ordering::Greater => match self.x.cmp(&self.z) {
+                Ordering::Less => Some(Z),
+                Ordering::Equal => None,
+                Ordering::Greater => Some(X),
+            },
+        }
+    }
+
+    /// Axis of the vector's highest value. [`None`] if at least two components are equal.
+    pub fn min_axis(self) -> Option<Vector3Axis> {
+        use Vector3Axis::*;
+
+        match self.x.cmp(&self.y) {
+            Ordering::Less => match self.x.cmp(&self.z) {
+                Ordering::Less => Some(X),
+                Ordering::Equal => None,
+                Ordering::Greater => Some(Z),
+            },
+            Ordering::Equal => match self.x.cmp(&self.z) {
+                Ordering::Greater => Some(Z),
+                _ => None,
+            },
+            Ordering::Greater => match self.y.cmp(&self.z) {
+                Ordering::Less => Some(Y),
+                Ordering::Equal => None,
+                Ordering::Greater => Some(Z),
+            },
+        }
+    }
+
     /// Constructs a new `Vector3i` with all components set to `v`.
     pub const fn splat(v: i32) -> Self {
         Self::new(v, v, v)
@@ -80,13 +125,18 @@ impl Vector3i {
     }
 
     /// Converts the corresponding `glam` type to `Self`.
-    fn from_glam(v: IVec3) -> Self {
+    fn from_glam(v: glam::IVec3) -> Self {
         Self::new(v.x, v.y, v.z)
     }
 
     /// Converts `self` to the corresponding `glam` type.
-    fn to_glam(self) -> IVec3 {
-        IVec3::new(self.x, self.y, self.z)
+    fn to_glam(self) -> glam::IVec3 {
+        glam::IVec3::new(self.x, self.y, self.z)
+    }
+
+    /// Converts `self` to the corresponding [`real`] `glam` type.
+    fn to_glam_real(self) -> RVec3 {
+        RVec3::new(self.x as real, self.y as real, self.z as real)
     }
 
     pub fn coords(&self) -> (i32, i32, i32) {
@@ -102,6 +152,8 @@ impl fmt::Display for Vector3i {
 }
 
 impl_common_vector_fns!(Vector3i, i32);
+impl_integer_vector_glam_fns!(Vector3i, real);
+impl_integer_vector_component_fns!(Vector3i, real, (x, y, z));
 impl_vector_operators!(Vector3i, i32, (x, y, z));
 impl_from_tuple_for_vector3x!(Vector3i, i32);
 
@@ -111,20 +163,20 @@ unsafe impl GodotFfi for Vector3i {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 
-impl GlamType for IVec3 {
+impl GlamType for glam::IVec3 {
     type Mapped = Vector3i;
 
     fn to_front(&self) -> Self::Mapped {
         Vector3i::new(self.x, self.y, self.z)
     }
 
     fn from_front(mapped: &Self::Mapped) -> Self {
-        IVec3::new(mapped.x, mapped.y, mapped.z)
+        glam::IVec3::new(mapped.x, mapped.y, mapped.z)
     }
 }
 
 impl GlamConv for Vector3i {
-    type Glam = IVec3;
+    type Glam = glam::IVec3;
 }
 
 #[cfg(test)]
@@ -147,4 +199,39 @@ mod test {
 
         crate::builtin::test_utils::roundtrip(&vector, expected_json);
     }
+
+    #[test]
+    fn axis_min_max() {
+        let x_max = Vector3i::new(10, 5, -5);
+        let y_max = Vector3i::new(5, 10, -5);
+        let z_max = Vector3i::new(5, -5, 10);
+
+        let x_min = Vector3i::new(-5, 5, 10);
+        let y_min = Vector3i::new(5, -5, 10);
+        let z_min = Vector3i::new(5, 10, -5);
+
+        let max_eq_2 = Vector3i::new(15, 15, 5);
+        let max_eq_3 = Vector3i::new(15, 15, 15);
+        let min_eq_2 = Vector3i::new(15, 15, 25);
+        let min_eq_3 = Vector3i::new(15, 15, 15);
+
+        let max_eq_trap = Vector3i::new(15, 15, 25);
+        let min_eq_trap = Vector3i::new(15, 5, 15);
+
+        assert_eq!(x_max.max_axis(), Some(Vector3Axis::X));
+        assert_eq!(y_max.max_axis(), Some(Vector3Axis::Y));
+        assert_eq!(z_max.max_axis(), Some(Vector3Axis::Z));
+
+        assert_eq!(x_min.min_axis(), Some(Vector3Axis::X));
+        assert_eq!(y_min.min_axis(), Some(Vector3Axis::Y));
+        assert_eq!(z_min.min_axis(), Some(Vector3Axis::Z));
+
+        assert_eq!(max_eq_2.max_axis(), None);
+        assert_eq!(max_eq_3.max_axis(), None);
+        assert_eq!(min_eq_2.min_axis(), None);
+        assert_eq!(min_eq_3.min_axis(), None);
+
+        assert_eq!(max_eq_trap.max_axis(), Some(Vector3Axis::Z));
+        assert_eq!(min_eq_trap.min_axis(), Some(Vector3Axis::Y));
+    }
 }