Merge Fixes

Fixed The resolved files from various compiler errors (mostly to match new internals) including the rust formatting... and clippy complainers. i think rustic for emacs is broken, as these small things are normally automatically handled

Author: RealAstolfo

godot-core/src/builtin/math.rs

@@ -66,6 +66,7 @@ pub fn cubic_interpolate(from: f32, to: f32, pre: f32, post: f32, weight: f32) -
         + (-pre + 3.0 * from - 3.0 * to + post) * (weight * weight * weight))
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn cubic_interpolate_in_time(
     from: f32,
     to: f32,

godot-core/src/builtin/mod.rs

@@ -37,6 +37,7 @@ mod vector_macros;
 
 mod arrays;
 mod color;
+mod math;
 mod node_path;
 mod others;
 mod string;
@@ -53,6 +54,7 @@ pub mod meta;
 
 pub use arrays::*;
 pub use color::*;
+pub use math::*;
 pub use node_path::*;
 pub use others::*;
 pub use string::*;

godot-core/src/builtin/vector2.rs

@@ -3,12 +3,13 @@
  * 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/.
  */
-use std::ops::*;
 use std::fmt;
+use std::ops::*;
 
 use godot_ffi as sys;
 use sys::{ffi_methods, GodotFfi};
 
+use crate::builtin::math::*;
 use crate::builtin::{inner, Vector2i};
 
 /// Vector used for 2D math using floating point coordinates.
@@ -80,10 +81,6 @@ impl Vector2 {
         glam::Vec2::new(self.x, self.y)
     }
 
-    pub fn abs(self) -> Self {
-        Self(self.to_glam().abs())
-    }
-
     pub fn angle(self) -> f32 {
         self.y.atan2(self.x)
     }
@@ -100,91 +97,44 @@ impl Vector2 {
         self.x / self.y
     }
 
-    pub fn bezier_derivative(
-        self,
-        control_1: Self,
-        control_2: Self,
-        end: Self,
-        t: f32,
-    ) -> Self {
-        let x = bezier_derivative(
-            self.x,
-            control_1.x,
-            control_2.x,
-            end.x,
-            t,
-        );
-        let y = bezier_derivative(
-            self.y,
-            control_1.y,
-            control_2.y,
-            end.y,
-            t,
-        );
+    pub fn bezier_derivative(self, control_1: Self, control_2: Self, end: Self, t: f32) -> Self {
+        let x = bezier_derivative(self.x, control_1.x, control_2.x, end.x, t);
+        let y = bezier_derivative(self.y, control_1.y, control_2.y, end.y, t);
 
-	Self::new(x, y)
+        Self::new(x, y)
     }
 
-    pub fn bezier_interpolate(
-        self,
-        control_1: Self,
-        control_2: Self,
-        end: Self,
-        t: f32,
-    ) -> Self {
-        let x = bezier_interpolate(
-            self.x,
-            control_1.x,
-            control_2.x,
-            end.x,
-            t,
-        );
-        let y = bezier_interpolate(
-            self.y,
-            control_1.y,
-            control_2.y,
-            end.y,
-            t,
-        );
+    pub fn bezier_interpolate(self, control_1: Self, control_2: Self, end: Self, t: f32) -> Self {
+        let x = bezier_interpolate(self.x, control_1.x, control_2.x, end.x, t);
+        let y = bezier_interpolate(self.y, control_1.y, control_2.y, end.y, t);
 
-	Self::new(x, y)
+        Self::new(x, y)
     }
 
     pub fn bounce(self, normal: Self) -> Self {
         -self.reflect(normal)
     }
 
     pub fn ceil(self) -> Self {
-        Self(self.to_glam().ceil())
+        Self::from_glam(self.to_glam().ceil())
     }
 
     pub fn clamp(self, min: Self, max: Self) -> Self {
-        Self(self.to_glam().clamp(min.to_glam(), max.to_glam()))
+        Self::from_glam(self.to_glam().clamp(min.to_glam(), max.to_glam()))
     }
 
     pub fn cross(self, with: Self) -> f32 {
         self.to_glam().perp_dot(with.to_glam())
     }
 
     pub fn cubic_interpolate(self, b: Self, pre_a: Self, post_b: Self, weight: f32) -> Self {
-        let x = cubic_interpolate(
-            self.x,
-            b.x,
-            pre_a.x,
-            post_b.x,
-            weight,
-        );
-        let y = cubic_interpolate(
-            self.y,
-            b.y,
-            pre_a.y,
-            post_b.y,
-            weight,
-        );
+        let x = cubic_interpolate(self.x, b.x, pre_a.x, post_b.x, weight);
+        let y = cubic_interpolate(self.y, b.y, pre_a.y, post_b.y, weight);
 
-	Self::new(x, y)
+        Self::new(x, y)
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub fn cubic_interpolate_in_time(
         self,
         b: Self,
@@ -196,27 +146,13 @@ impl Vector2 {
         post_b_t: f32,
     ) -> Self {
         let x = cubic_interpolate_in_time(
-            self.x,
-            b.x,
-            pre_a.x,
-            post_b.x,
-            weight,
-            b_t,
-            pre_a_t,
-            post_b_t,
+            self.x, b.x, pre_a.x, post_b.x, weight, b_t, pre_a_t, post_b_t,
         );
         let y = cubic_interpolate_in_time(
-            self.y,
-            b.y,
-            pre_a.y,
-            post_b.y,
-            weight,
-            b_t,
-            pre_a_t,
-            post_b_t,
+            self.y, b.y, pre_a.y, post_b.y, weight, b_t, pre_a_t, post_b_t,
         );
 
-	Self::new(x, y)
+        Self::new(x, y)
     }
 
     pub fn direction_to(self, to: Self) -> Self {
@@ -264,37 +200,31 @@ impl Vector2 {
     }
 
     pub fn lerp(self, to: Self, weight: f32) -> Self {
-        Self(self.to_glam().lerp(to.to_glam(), weight))
+        Self::from_glam(self.to_glam().lerp(to.to_glam(), weight))
     }
 
     pub fn limit_length(self, length: Option<f32>) -> Self {
-        Self(self.to_glam().clamp_length_max(length.unwrap_or(1.0)))
+        Self::from_glam(self.to_glam().clamp_length_max(length.unwrap_or(1.0)))
     }
 
     pub fn max_axis_index(self) -> i32 {
-        if self.to_glam().max_element() == self.x {
-            0
-        } else {
-            1
-        }
+        let me = self.to_glam().max_element();
+        (me == self.y) as i32
     }
 
     pub fn min_axis_index(self) -> i32 {
-        if self.to_glam().min_element() == self.x {
-            0
-        } else {
-            1
-        }
+        let me = self.to_glam().min_element();
+        (me == self.y) as i32
     }
 
     pub fn move_toward(self, to: Self, delta: f32) -> Self {
         let vd = to - self;
         let len = vd.length();
         if len <= delta || len < CMP_EPSILON {
-            return to;
+            to
         } else {
-            return self + vd / len * delta;
-        };
+            self + vd / len * delta
+        }
     }
 
     pub fn orthogonal(self) -> Self {
@@ -306,10 +236,7 @@ impl Vector2 {
     }
 
     pub fn posmodv(self, modv: Self) -> Self {
-        Self::new(
-            fposmod(self.x, modv.x),
-            fposmod(self.y, modv.y),
-        )
+        Self::new(fposmod(self.x, modv.x), fposmod(self.y, modv.y))
     }
 
     pub fn project(self, b: Self) -> Self {
@@ -345,17 +272,14 @@ impl Vector2 {
     }
 
     pub fn snapped(self, step: Self) -> Self {
-        Self::new(
-            snapped(self.x, step.x),
-            snapped(self.y, step.y),
-        )
+        Self::new(snapped(self.x, step.x), snapped(self.y, step.y))
     }
 
     /// Returns the result of rotating this vector by `angle` (in radians).
     pub fn rotated(self, angle: f32) -> Self {
         Self::from_glam(glam::Affine2::from_angle(angle).transform_vector2(self.to_glam()))
     }
-    
+
     #[cfg(not(any(gdext_test, doctest)))]
     #[doc(hidden)]
     pub fn as_inner(&self) -> inner::InnerVector2 {