Split swizzle functionality into own file

Rename trait ToVector -> SwizzleToVector and make it doc-private

Author: Bromeon

godot-core/src/builtin/mod.rs

@@ -63,13 +63,10 @@ pub mod __prelude_reexport {
     pub use rid::Rid;
     pub use signal::Signal;
     pub use string::{GString, NodePath, StringName};
-    pub use transform2d::Transform2D;
-    pub use transform3d::Transform3D;
-    pub use variant::Variant;
-    pub use vectors::{
-        swizzle, ToVector, Vector2, Vector2Axis, Vector2i, Vector3, Vector3Axis, Vector3i,
-        Vector4, Vector4Axis, Vector4i,
-    };
+    pub use transform2d::*;
+    pub use transform3d::*;
+    pub use variant::*;
+    pub use vectors::*;
 
     pub use super::{EulerOrder, Side, VariantOperator, VariantType};
     pub use crate::{array, dict, real, reals, varray};

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

@@ -5,6 +5,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
+// Must be first.
 mod vector_macros;
 
 mod vector2;
@@ -14,6 +15,7 @@ mod vector3i;
 mod vector4;
 mod vector4i;
 mod vector_axis;
+mod vector_swizzle;
 
 pub use vector2::*;
 pub use vector2i::*;
@@ -22,5 +24,6 @@ pub use vector3i::*;
 pub use vector4::*;
 pub use vector4i::*;
 pub use vector_axis::*;
+pub use vector_swizzle::*;
 
 pub use crate::swizzle;

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

@@ -245,7 +245,7 @@ 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);
+impl_swizzle_trait_for_vector2x!(Vector2, real);
 
 // SAFETY:
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.

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

@@ -126,7 +126,7 @@ 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);
+impl_swizzle_trait_for_vector2x!(Vector2i, i32);
 
 // SAFETY:
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.

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

@@ -276,7 +276,7 @@ impl_common_vector_fns!(Vector3, real);
 impl_float_vector_glam_fns!(Vector3, real);
 impl_float_vector_component_fns!(Vector3, real, (x, y, z));
 impl_vector_operators!(Vector3, real, (x, y, z));
-impl_from_tuple_for_vector3x!(Vector3, real);
+impl_swizzle_trait_for_vector3x!(Vector3, real);
 
 // SAFETY:
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.

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

@@ -157,7 +157,7 @@ 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);
+impl_swizzle_trait_for_vector3x!(Vector3i, i32);
 
 // SAFETY:
 // This type is represented as `Self` in Godot, so `*mut Self` is sound.

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

@@ -44,7 +44,7 @@ impl_vector_operators!(Vector4, real, (x, y, z, w));
 impl_common_vector_fns!(Vector4, real);
 impl_float_vector_glam_fns!(Vector4, real);
 impl_float_vector_component_fns!(Vector4, real, (x, y, z, w));
-impl_from_tuple_for_vector4x!(Vector4, real);
+impl_swizzle_trait_for_vector4x!(Vector4, real);
 
 impl Vector4 {
     /// Returns a `Vector4` with the given components.

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

@@ -43,7 +43,7 @@ impl_vector_operators!(Vector4i, i32, (x, y, z, w));
 impl_integer_vector_glam_fns!(Vector4i, real);
 impl_integer_vector_component_fns!(Vector4i, real, (x, y, z, w));
 impl_common_vector_fns!(Vector4i, i32);
-impl_from_tuple_for_vector4x!(Vector4i, i32);
+impl_swizzle_trait_for_vector4x!(Vector4i, i32);
 
 impl Vector4i {
     /// Returns a `Vector4i` with the given components.

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

@@ -9,70 +9,6 @@ use crate::builtin::meta::{ConvertError, FromGodot, FromGodotError, GodotConvert
 use crate::builtin::{real, Vector2, Vector2i, Vector3, Vector3i, Vector4, Vector4i};
 use crate::obj::EngineEnum;
 
-/// Access vector components in different order.
-///
-/// Allows to rearrange components, as well as to create higher- or lower-order vectors.
-///
-/// This macro supports all vector types (2D, 3D, 4D; both integer and float). The resulting vector
-/// type is deduced from the number and types of components.
-///
-/// To repeat a single component, check out the `splat` method on specific vector types.
-///
-/// # Examples
-///
-/// Reorder or duplicate fields:
-/// ```
-/// use godot::prelude::*;
-///
-/// let vec3 = Vector3i::new(1, 2, 3);
-/// let xzx = swizzle!(vec3 => x, z, x); // Vector3i
-///
-/// assert_eq!(xzx, Vector3i::new(1, 3, 1));
-/// ```
-///
-/// Create lower-order vector:
-/// ```
-/// # use godot::prelude::*;
-/// let vec4 = Vector4::new(1.0, 2.0, 3.0, 4.0);
-/// let yw = swizzle!(vec4 => y, w); // Vector2
-///
-/// assert_eq!(yw, Vector2::new(2.0, 4.0));
-/// ```
-///
-/// Create higher-order vector:
-/// ```
-/// # use godot::prelude::*;
-/// let vec3 = Vector3i::new(1, 2, 3);
-/// let xyyz = swizzle!(vec3 => x, y, y, z); // Vector4i
-///
-/// assert_eq!(xyyz, Vector4i::new(1, 2, 2, 3));
-/// ```
-#[macro_export]
-macro_rules! swizzle {
-    ($vec:expr => $a:ident, $b:ident) => {{
-        let expr = $vec;
-        $crate::builtin::ToVector::to_vector((expr.$a, expr.$b))
-    }};
-    ($vec:expr => $a:ident, $b:ident, $c:ident) => {{
-        let expr = $vec;
-        $crate::builtin::ToVector::to_vector((expr.$a, expr.$b, expr.$c))
-    }};
-    ($vec:expr => $a:ident, $b:ident, $c:ident, $d:ident) => {{
-        let expr = $vec;
-        $crate::builtin::ToVector::to_vector((expr.$a, expr.$b, expr.$c, expr.$d))
-    }};
-}
-
-// ----------------------------------------------------------------------------------------------------------------------------------------------
-
-/// Trait that allows conversion from tuples to vectors.
-///
-/// Is implemented instead of `From`/`Into` because it provides type inference.
-pub trait ToVector: Sized {
-    type Output;
-    fn to_vector(self) -> Self::Output;
-}
-
 macro_rules! impl_vector_axis_enum {
     ($Vector:ident, $AxisEnum:ident, ($($axis:ident),+)) => {
         #[doc = concat!("Enumerates the axes in a [`", stringify!($Vector), "`].")]
@@ -135,63 +71,3 @@ impl_vector_index!(Vector3i, i32, (x, y, z), Vector3Axis, (X, Y, Z));
 
 impl_vector_index!(Vector4, real, (x, y, z, w), Vector4Axis, (X, Y, Z, W));
 impl_vector_index!(Vector4i, i32, (x, y, z, w), Vector4Axis, (X, Y, Z, W));
-
-// ----------------------------------------------------------------------------------------------------------------------------------------------
-
-#[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 vec2swiz2: Vector2 = swizzle!(vector2 => y, x);
-        let vec3swiz2: Vector2 = swizzle!(vector3 => y, x);
-        let vec4swiz2: Vector2 = swizzle!(vector4 => y, x);
-        assert_eq_approx!(vec2swiz2, Vector2::new(2.0, 1.0));
-        assert_eq_approx!(vec3swiz2, Vector2::new(2.0, 1.0));
-        assert_eq_approx!(vec4swiz2, Vector2::new(2.0, 1.0));
-
-        // VectorN to Vector3
-        let vec2swiz3: Vector3 = swizzle!(vector2 => y, x, x);
-        let vec3swiz3: Vector3 = swizzle!(vector3 => y, x, z);
-        let vec4swiz3: Vector3 = swizzle!(vector4 => y, x, z);
-        assert_eq_approx!(vec2swiz3, Vector3::new(2.0, 1.0, 1.0),);
-        assert_eq_approx!(vec3swiz3, Vector3::new(2.0, 1.0, 3.0),);
-        assert_eq_approx!(vec4swiz3, Vector3::new(2.0, 1.0, 3.0),);
-
-        // VectorN to Vector4
-        let vec2swiz4: Vector4 = swizzle!(vector2 => y, x, x, y);
-        let vec3swiz4: Vector4 = swizzle!(vector3 => y, x, z, y);
-        let vec4swiz4: Vector4 = swizzle!(vector4 => y, x, z, w);
-        assert_eq_approx!(vec2swiz4, Vector4::new(2.0, 1.0, 1.0, 2.0),);
-        assert_eq_approx!(vec3swiz4, Vector4::new(2.0, 1.0, 3.0, 2.0),);
-        assert_eq_approx!(vec4swiz4, Vector4::new(2.0, 1.0, 3.0, 4.0),);
-
-        // * 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!(swizzle!(vector3i => y, x), Vector2i::new(2, 1));
-        assert_eq!(swizzle!(vector4i => y, x), Vector2i::new(2, 1));
-
-        // VectorNi to Vector3i
-        assert_eq!(swizzle!(vector2i => y, x, x), Vector3i::new(2, 1, 1));
-        assert_eq!(swizzle!(vector3i => y, x, z), Vector3i::new(2, 1, 3));
-        assert_eq!(swizzle!(vector4i => y, x, z), Vector3i::new(2, 1, 3));
-
-        // VectorNi to Vector4i
-        assert_eq!(swizzle!(vector2i => y, x, x, y), Vector4i::new(2, 1, 1, 2));
-        assert_eq!(swizzle!(vector3i => y, x, z, y), Vector4i::new(2, 1, 3, 2));
-        assert_eq!(swizzle!(vector4i => y, x, z, w), Vector4i::new(2, 1, 3, 4));
-    }
-}

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

@@ -476,42 +476,33 @@ macro_rules! impl_integer_vector_component_fns {
     };
 }
 
-macro_rules! impl_from_tuple_for_vector2x {
-    (
-        $Vector:ty,
-        $Scalar:ty
-    ) => {
-        impl $crate::builtin::ToVector for ($Scalar, $Scalar) {
+macro_rules! impl_swizzle_trait_for_vector2x {
+    ($Vector:ty, $Scalar:ty) => {
+        impl $crate::builtin::SwizzleToVector for ($Scalar, $Scalar) {
             type Output = $Vector;
-            fn to_vector(self) -> $Vector {
+            fn swizzle_to_vector(self) -> $Vector {
                 <$Vector>::new(self.0, self.1)
             }
         }
     };
 }
 
-macro_rules! impl_from_tuple_for_vector3x {
-    (
-        $Vector:ty,
-        $Scalar:ty
-    ) => {
-        impl $crate::builtin::ToVector for ($Scalar, $Scalar, $Scalar) {
+macro_rules! impl_swizzle_trait_for_vector3x {
+    ($Vector:ty, $Scalar:ty) => {
+        impl $crate::builtin::SwizzleToVector for ($Scalar, $Scalar, $Scalar) {
             type Output = $Vector;
-            fn to_vector(self) -> $Vector {
+            fn swizzle_to_vector(self) -> $Vector {
                 <$Vector>::new(self.0, self.1, self.2)
             }
         }
     };
 }
 
-macro_rules! impl_from_tuple_for_vector4x {
-    (
-        $Vector:ty,
-        $Scalar:ty
-    ) => {
-        impl $crate::builtin::ToVector for ($Scalar, $Scalar, $Scalar, $Scalar) {
+macro_rules! impl_swizzle_trait_for_vector4x {
+    ($Vector:ty, $Scalar:ty) => {
+        impl $crate::builtin::SwizzleToVector for ($Scalar, $Scalar, $Scalar, $Scalar) {
             type Output = $Vector;
-            fn to_vector(self) -> $Vector {
+            fn swizzle_to_vector(self) -> $Vector {
                 <$Vector>::new(self.0, self.1, self.2, self.3)
             }
         }