Implements swizzle and converts from/to tuples

Author: hapenia

godot-core/src/builtin/mod.rs

@@ -54,12 +54,13 @@ pub use string::*;
 pub use transform2d::*;
 pub use transform3d::*;
 pub use variant::*;
-pub use vector2::*;
-pub use vector2i::*;
-pub use vector3::*;
-pub use vector3i::*;
-pub use vector4::*;
-pub use vector4i::*;
+pub use vectors::vector2::*;
+pub use vectors::vector2i::*;
+pub use vectors::vector3::*;
+pub use vectors::vector3i::*;
+pub use vectors::vector4::*;
+pub use vectors::vector4i::*;
+pub use vectors::vector_utils::*;
 
 /// Meta-information about variant types, properties and class names.
 pub mod meta;
@@ -79,7 +80,6 @@ pub mod dictionary {
 
 // Modules exporting declarative macros must appear first.
 mod macros;
-mod vector_macros;
 
 // Rename imports because we re-export a subset of types under same module names.
 #[path = "array.rs"]
@@ -105,12 +105,7 @@ mod string;
 mod transform2d;
 mod transform3d;
 mod variant;
-mod vector2;
-mod vector2i;
-mod vector3;
-mod vector3i;
-mod vector4;
-mod vector4i;
+mod vectors;
 
 #[doc(hidden)]
 pub mod inner {

godot-core/src/builtin/quaternion.rs

@@ -9,7 +9,7 @@ use godot_ffi as sys;
 use sys::{ffi_methods, GodotFfi};
 
 use crate::builtin::glam_helpers::{GlamConv, GlamType};
-use crate::builtin::{inner, math::*, vector3::*};
+use crate::builtin::{inner, math::*, Vector3};
 
 use super::{real, RQuat};
 use super::{Basis, EulerOrder};

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

@@ -0,0 +1,97 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+mod vector_macros;
+
+pub mod vector2;
+pub mod vector2i;
+pub mod vector3;
+pub mod vector3i;
+pub mod vector4;
+pub mod vector4i;
+
+pub mod vector_utils;
+
+#[cfg(test)]
+mod test {
+    use crate::assert_eq_approx;
+    use crate::builtin::*;
+    #[test]
+    fn test_vector_swizzle() {
+        // * VectorN swizzle
+        let vector2 = Vector2::new(1.0, 2.0);
+        let vector3 = Vector3::new(1.0, 2.0, 3.0);
+        let vector4 = Vector4::new(1.0, 2.0, 3.0, 4.0);
+
+        // VectorN to Vector2
+
+        let vc2swiz2: Vector2 = swizzle!(vector2 => y, x);
+        let vc3swiz2: Vector2 = swizzle!(vector3 => y, x);
+        let vc4swiz2: Vector2 = swizzle!(vector4 => y, x);
+        assert_eq_approx!(Vector2::new(2.0, 1.0), vc2swiz2, Vector2::is_equal_approx);
+        assert_eq_approx!(Vector2::new(2.0, 1.0), vc3swiz2, Vector2::is_equal_approx);
+        assert_eq_approx!(Vector2::new(2.0, 1.0), vc4swiz2, Vector2::is_equal_approx);
+
+        // VectorN to Vector3
+
+        let vc2swiz3: Vector3 = swizzle!(vector2 => y, x, x);
+        let vc3swiz3: Vector3 = swizzle!(vector3 => y, x, z);
+        let vc4swiz3: Vector3 = swizzle!(vector4 => y, x, z);
+        assert_eq_approx!(
+            Vector3::new(2.0, 1.0, 1.0),
+            vc2swiz3,
+            Vector3::is_equal_approx
+        );
+        assert_eq_approx!(
+            Vector3::new(2.0, 1.0, 3.0),
+            vc3swiz3,
+            Vector3::is_equal_approx
+        );
+        assert_eq_approx!(
+            Vector3::new(2.0, 1.0, 3.0),
+            vc4swiz3,
+            Vector3::is_equal_approx
+        );
+
+        // VectorN to Vector4
+
+        let vc2swiz4: Vector4 = swizzle!(vector2 => y, x, x, y);
+        let vc3swiz4: Vector4 = swizzle!(vector3 => y, x, z, y);
+        let vc4swiz4: Vector4 = swizzle!(vector4 => y, x, z, w);
+        assert_eq_approx!(
+            Vector4::new(2.0, 1.0, 1.0, 2.0),
+            vc2swiz4,
+            Vector4::is_equal_approx
+        );
+        assert_eq_approx!(
+            Vector4::new(2.0, 1.0, 3.0, 2.0),
+            vc3swiz4,
+            Vector4::is_equal_approx
+        );
+        assert_eq_approx!(
+            Vector4::new(2.0, 1.0, 3.0, 4.0),
+            vc4swiz4,
+            Vector4::is_equal_approx
+        );
+
+        // * VectorNi swizzle
+        let vector2i = Vector2i::new(1, 2);
+        let vector3i = Vector3i::new(1, 2, 3);
+        let vector4i = Vector4i::new(1, 2, 3, 4);
+        // VectorNi to Vector2i
+        assert_eq!(Vector2i::new(2, 1), swizzle!(vector2i => y, x));
+        assert_eq!(Vector2i::new(2, 1), swizzle!(vector3i => y, x));
+        assert_eq!(Vector2i::new(2, 1), swizzle!(vector4i => y, x));
+        // VectorNi to Vector3i
+        assert_eq!(Vector3i::new(2, 1, 1), swizzle!(vector2i => y, x, x));
+        assert_eq!(Vector3i::new(2, 1, 3), swizzle!(vector3i => y, x, z));
+        assert_eq!(Vector3i::new(2, 1, 3), swizzle!(vector4i => y, x, z));
+        // VectorNi to Vector4i
+        assert_eq!(Vector4i::new(2, 1, 1, 2), swizzle!(vector2i => y, x, x, y));
+        assert_eq!(Vector4i::new(2, 1, 3, 2), swizzle!(vector3i => y, x, z, y));
+        assert_eq!(Vector4i::new(2, 1, 3, 4), swizzle!(vector4i => y, x, z, w));
+    }
+}

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

@@ -12,9 +12,10 @@ use sys::{ffi_methods, GodotFfi};
 use crate::builtin::math::*;
 use crate::builtin::{inner, Vector2i};
 
-use super::glam_helpers::GlamConv;
-use super::glam_helpers::GlamType;
-use super::{real, RAffine2, RVec2};
+use super::super::glam_helpers::GlamConv;
+use super::super::glam_helpers::GlamType;
+use super::super::{real, RAffine2, RVec2};
+use super::vector_utils::*;
 
 /// Vector used for 2D math using floating point coordinates.
 ///
@@ -298,6 +299,10 @@ impl Vector2 {
     pub fn as_inner(&self) -> inner::InnerVector2 {
         inner::InnerVector2::from_outer(self)
     }
+
+    pub fn coords(&self) -> (real, real) {
+        (self.x, self.y)
+    }
 }
 
 /// Formats the vector like Godot: `(x, y)`.
@@ -310,29 +315,16 @@ impl fmt::Display for Vector2 {
 impl_common_vector_fns!(Vector2, real);
 impl_float_vector_fns!(Vector2, real);
 impl_vector_operators!(Vector2, real, (x, y));
-impl_vector_index!(Vector2, real, (x, y), Vector2Axis, (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 {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 
-/// Enumerates the axes in a [`Vector2`].
-#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
-#[repr(i32)]
-pub enum Vector2Axis {
-    /// The X axis.
-    X,
-
-    /// The Y axis.
-    Y,
-}
-
-// SAFETY:
-// This type is represented as `Self` in Godot, so `*mut Self` is sound.
-unsafe impl GodotFfi for Vector2Axis {
-    ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
+impl GlamConv for Vector2 {
+    type Glam = RVec2;
 }
 
 impl GlamType for RVec2 {
@@ -347,10 +339,6 @@ impl GlamType for RVec2 {
     }
 }
 
-impl GlamConv for Vector2 {
-    type Glam = RVec2;
-}
-
 #[cfg(test)]
 mod test {
     use crate::assert_eq_approx;

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

@@ -9,11 +9,10 @@ use std::fmt;
 use godot_ffi as sys;
 use sys::{ffi_methods, GodotFfi};
 
+use crate::builtin::glam_helpers::{GlamConv, GlamType};
+use crate::builtin::IVec2;
 use crate::builtin::Vector2;
 
-use super::glam_helpers::{GlamConv, GlamType};
-use super::IVec2;
-
 /// Vector used for 2D math using integer coordinates.
 ///
 /// 2-element structure that can be used to represent positions in 2D space or any other pair of
@@ -80,6 +79,10 @@ impl Vector2i {
     fn to_glam(self) -> glam::IVec2 {
         IVec2::new(self.x, self.y)
     }
+
+    pub fn coords(&self) -> (i32, i32) {
+        (self.x, self.y)
+    }
 }
 
 /// Formats the vector like Godot: `(x, y)`.
@@ -91,31 +94,14 @@ impl fmt::Display for Vector2i {
 
 impl_common_vector_fns!(Vector2i, i32);
 impl_vector_operators!(Vector2i, i32, (x, y));
-impl_vector_index!(Vector2i, i32, (x, y), Vector2iAxis, (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 {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 
-/// Enumerates the axes in a [`Vector2i`].
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
-#[repr(i32)]
-pub enum Vector2iAxis {
-    /// The X axis.
-    X,
-
-    /// The Y axis.
-    Y,
-}
-
-// SAFETY:
-// This type is represented as `Self` in Godot, so `*mut Self` is sound.
-unsafe impl GodotFfi for Vector2iAxis {
-    ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
-}
-
 impl GlamType for IVec2 {
     type Mapped = Vector2i;
 

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

@@ -13,9 +13,10 @@ use sys::{ffi_methods, GodotFfi};
 use crate::builtin::math::*;
 use crate::builtin::Vector3i;
 
-use super::glam_helpers::GlamConv;
-use super::glam_helpers::GlamType;
-use super::{real, Basis, RVec3};
+use super::super::glam_helpers::GlamConv;
+use super::super::glam_helpers::GlamType;
+use super::super::{real, Basis, RVec3};
+use super::vector_utils::*;
 
 /// Vector used for 3D math using floating point coordinates.
 ///
@@ -318,6 +319,10 @@ impl Vector3 {
         assert!(axis.is_normalized());
         Basis::from_axis_angle(axis, angle) * self
     }
+
+    pub fn coords(&self) -> (real, real, real) {
+        (self.x, self.y, self.z)
+    }
 }
 
 /// Formats the vector like Godot: `(x, y, z)`.
@@ -330,35 +335,14 @@ impl fmt::Display for Vector3 {
 impl_common_vector_fns!(Vector3, real);
 impl_float_vector_fns!(Vector3, real);
 impl_vector_operators!(Vector3, real, (x, y, z));
-impl_vector_index!(Vector3, real, (x, y, z), Vector3Axis, (X, Y, Z));
+impl_from_tuple_for_vector3x!(Vector3, real);
 
 // SAFETY:
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.
 unsafe impl GodotFfi for Vector3 {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 
-/// Enumerates the axes in a [`Vector3`].
-// TODO auto-generate this, alongside all the other builtin type's enums
-#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
-#[repr(i32)]
-pub enum Vector3Axis {
-    /// The X axis.
-    X,
-
-    /// The Y axis.
-    Y,
-
-    /// The Z axis.
-    Z,
-}
-
-// SAFETY:
-// This type is represented as `Self` in Godot, so `*mut Self` is sound.
-unsafe impl GodotFfi for Vector3Axis {
-    ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
-}
-
 impl GlamType for RVec3 {
     type Mapped = Vector3;
 

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

@@ -11,8 +11,8 @@ use sys::{ffi_methods, GodotFfi};
 
 use crate::builtin::Vector3;
 
-use super::glam_helpers::{GlamConv, GlamType};
-use super::IVec3;
+use super::super::glam_helpers::{GlamConv, GlamType};
+use super::super::IVec3;
 
 /// Vector used for 3D math using integer coordinates.
 ///
@@ -90,6 +90,10 @@ impl Vector3i {
     fn to_glam(self) -> IVec3 {
         IVec3::new(self.x, self.y, self.z)
     }
+
+    pub fn coords(&self) -> (i32, i32, i32) {
+        (self.x, self.y, self.z)
+    }
 }
 
 /// Formats the vector like Godot: `(x, y, z)`.
@@ -101,34 +105,14 @@ impl fmt::Display for Vector3i {
 
 impl_common_vector_fns!(Vector3i, i32);
 impl_vector_operators!(Vector3i, i32, (x, y, z));
-impl_vector_index!(Vector3i, i32, (x, y, z), Vector3iAxis, (X, Y, Z));
+impl_from_tuple_for_vector3x!(Vector3i, i32);
 
 // SAFETY:
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.
 unsafe impl GodotFfi for Vector3i {
     ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
 }
 
-/// Enumerates the axes in a [`Vector3i`].
-#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
-#[repr(i32)]
-pub enum Vector3iAxis {
-    /// The X axis.
-    X,
-
-    /// The Y axis.
-    Y,
-
-    /// The Z axis.
-    Z,
-}
-
-// SAFETY:
-// This type is represented as `Self` in Godot, so `*mut Self` is sound.
-unsafe impl GodotFfi for Vector3iAxis {
-    ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
-}
-
 impl GlamType for IVec3 {
     type Mapped = Vector3i;