Follow-up changes to swizzling and tuple conversion

Changes:
* Add type inference to swizzle!()
* Module structure + macro publicly accessible
* Instead of From<Tuple>, use ToVector trait
* Documentation

Author: Bromeon

godot-core/src/builtin/mod.rs

@@ -54,13 +54,7 @@ pub use string::*;
 pub use transform2d::*;
 pub use transform3d::*;
 pub use variant::*;
-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::*;
+pub use vectors::*;
 
 /// Meta-information about variant types, properties and class names.
 pub mod meta;
@@ -195,7 +189,10 @@ mod real_mod {
         }
     }
 
-    pub use std::f32::consts;
+    /// Re-export of [`std::f32::consts`] or [`std::f64::consts`], depending on precision config.
+    pub mod real_consts {
+        pub use std::f32::consts::*;
+    }
 
     /// A 2-dimensional vector from [`glam`]. Using a floating-point format compatible with [`real`].
     pub type RVec2 = glam::Vec2;
@@ -262,7 +259,10 @@ mod real_mod {
         }
     }
 
-    pub use std::f64::consts;
+    /// Re-export of [`std::f32::consts`] or [`std::f64::consts`], depending on precision config.
+    pub mod real_consts {
+        pub use std::f64::consts::*;
+    }
 
     /// A 2-dimensional vector from [`glam`]. Using a floating-point format compatible with [`real`].
     pub type RVec2 = glam::DVec2;
@@ -292,26 +292,29 @@ mod real_mod {
 
 pub use crate::real;
 pub(crate) use real_mod::*;
-pub use real_mod::{consts as real_consts, real};
+
+pub use real_mod::{real, real_consts};
 
 pub(crate) use glam::{IVec2, IVec3, IVec4};
 
-/// A macro to coerce float-literals into the real type. Mainly used where
-/// you'd normally use a suffix to specity the type, such as `115.0f32`.
+/// A macro to coerce float-literals into the [`real`] type.
+///
+/// Mainly used where you'd normally use a suffix to specify the type, such as `115.0f32`.
+///
+/// # Examples
 ///
-/// ### Examples
-/// Rust will not know how to infer the type of this call to `to_radians`:
+/// Rust is not able to infer the `self` type of this call to `to_radians`:
 /// ```compile_fail
-/// use godot_core::builtin::real;
+/// use godot::builtin::real;
 ///
 /// let radians: real = 115.0.to_radians();
 /// ```
-/// But we can't add a suffix to the literal, since it may be either `f32` or
+/// But we cannot add a suffix to the literal, since it may be either `f32` or
 /// `f64` depending on the context. So instead we use our macro:
 /// ```
-/// use godot_core::builtin::real;
+/// use godot::builtin::real;
 ///
-/// let radians: real = godot_core::real!(115.0).to_radians();
+/// let radians: real = real!(115.0).to_radians();
 /// ```
 #[macro_export]
 macro_rules! real {

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

@@ -6,92 +6,20 @@
 
 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));
-    }
-}
+mod vector2;
+mod vector2i;
+mod vector3;
+mod vector3i;
+mod vector4;
+mod vector4i;
+mod vector_axis;
+
+pub use vector2::*;
+pub use vector2i::*;
+pub use vector3::*;
+pub use vector3i::*;
+pub use vector4::*;
+pub use vector4i::*;
+pub use vector_axis::*;
+
+pub use crate::swizzle;

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

@@ -15,7 +15,7 @@ use crate::builtin::{inner, Vector2i};
 use super::super::glam_helpers::GlamConv;
 use super::super::glam_helpers::GlamType;
 use super::super::{real, RAffine2, RVec2};
-use super::vector_utils::*;
+use super::vector_axis::*;
 
 /// Vector used for 2D math using floating point coordinates.
 ///

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

@@ -16,7 +16,7 @@ use crate::builtin::Vector3i;
 use super::super::glam_helpers::GlamConv;
 use super::super::glam_helpers::GlamType;
 use super::super::{real, Basis, RVec3};
-use super::vector_utils::*;
+use super::vector_axis::*;
 
 /// Vector used for 3D math using floating point coordinates.
 ///