Merge #225

225: Add a couple features for Vectors r=Bromeon a=Hapenia-Lans

Utilities for vectors. This pull request allows you to write these code:

```rust
let vec = Vector3i::new(1,2,3);
let (x,y,_) = vec.xyz();
let vec_reverted = Vector3i::from(vec.zyx());
let vec2i = Vector2i::from((x,y));

```
These functions' design still needs to be discussed. Another choice is something like this:

```rust
let vec = Vector3i::new(1,2,3);
let (x,y,z) = vec.tuplize(); // make it into tuple
let vec_reverted = vec.zyx();
let vec2i = vec.xy(); // this needs large amounts of functions decl
```


Co-authored-by: ChenXi <[email protected]>
Co-authored-by: Jan Haller <[email protected]>

Author: 3 people

godot-core/src/builtin/mod.rs

@@ -54,12 +54,7 @@ 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::*;
 
 /// Meta-information about variant types, properties and class names.
 pub mod meta;
@@ -79,7 +74,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 +99,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 {
@@ -200,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;
@@ -267,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;
@@ -297,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/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,25 @@
+/*
+ * 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;
+
+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/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_axis::*;
 
 /// 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_axis::*;
 
 /// 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;