PR adjustments; rename/deprecate Basis.inverted() -> inverse()

Author: Bromeon

gdnative-core/src/core_types/geom/basis.rs

@@ -1,6 +1,7 @@
 use crate::core_types::{IsEqualApprox, Quat, Vector3};
-use core::ops::Mul;
+use crate::globalscope::lerp;
 use glam::Mat3;
+use std::ops::Mul;
 
 /// A 3x3 matrix, typically used as an orthogonal basis for [`Transform`][crate::core_types::Transform].
 ///
@@ -241,37 +242,31 @@ impl Basis {
     ///
     /// If the determinant of `self` is zero.
     #[inline]
-    pub fn inverted(&self) -> Self {
+    pub fn inverse(&self) -> Self {
         let mut copy = *self;
         copy.invert();
         copy
     }
 
+    #[inline]
+    #[deprecated = "Use `inverse` instead."]
+    pub fn inverted(&self) -> Self {
+        self.inverse()
+    }
+
     /// Returns linear interpolation on a sphere between two basis by weight amount (on the range of 0.0 to 1.0).
     #[inline]
     pub fn slerp(&self, other: &Basis, weight: f32) -> Self {
-        #[inline]
-        fn lerp_f(from: f32, to: f32, weight: f32) -> f32 {
-            from + (to - from) * weight
-        }
         let from = self.to_quat();
         let to = other.to_quat();
         let mut result = Basis::from_quat(from.slerp(to, weight));
-        result.elements[0] *= lerp_f(
-            self.elements[0].length(),
-            other.elements[0].length(),
-            weight,
-        );
-        result.elements[1] *= lerp_f(
-            self.elements[1].length(),
-            other.elements[1].length(),
-            weight,
-        );
-        result.elements[2] *= lerp_f(
-            self.elements[2].length(),
-            other.elements[2].length(),
-            weight,
-        );
+
+        for i in 0..3 {
+            result.elements[i] *= lerp(
+                self.elements[i].length()..=other.elements[i].length(),
+                weight,
+            );
+        }
 
         result
     }
@@ -350,7 +345,7 @@ impl Basis {
     }
 
     #[inline]
-    pub fn orthogonalize(&mut self) {
+    fn orthogonalize(&mut self) {
         let scale = self.scale();
         self.orthonormalize();
         self.scale_local(scale);
@@ -855,6 +850,6 @@ mod tests {
             Vector3::new(-0.165055, 0.94041, -0.297299),
             Vector3::new(0.98324, 0.180557, 0.025257),
         );
-        assert!(expected.is_equal_approx(&b.inverted()));
+        assert!(expected.is_equal_approx(&b.inverse()));
     }
 }

gdnative-core/src/core_types/geom/transform.rs

@@ -2,6 +2,17 @@ use std::ops::Mul;
 
 use crate::core_types::{Basis, Vector3};
 
+// Note regarding naming of interpolation: there are 3 namings in Godot.
+// * `lerp` + `slerp` for simple types
+// * `linear_interpolate` for vectors and colors
+//    (now renamed to [`lerp`](https://docs.godotengine.org/en/latest/classes/class_vector3.html?highlight=vector3#class-vector3-method-lerp) + `slerp`)
+// * `Vector3` also has `cubic_interpolate` and `bezier_interpolate`, which might explain the origins
+// * `interpolate_with` for transforms; in Godot 4 also
+//   [`sphere_interpolate_with`](https://docs.godotengine.org/en/latest/classes/class_transform3d.html#class-transform3d-method-sphere-interpolate-with)
+//
+// We currently also have `Transform2D::interpolate_with()`.
+// In an ideal world, all those would be called `lerp` and `slerp`.
+
 /// Affine 3D transform (3x4 matrix).
 ///
 /// Used for 3D linear transformations. Uses a basis + origin representation.
@@ -89,7 +100,7 @@ impl Transform {
     /// Returns this transform, with its origin moved by a certain `translation`
     #[deprecated = "`translated` is not relative to the transform's coordinate system \
     and thus inconsistent with GDScript. Please use translated_global() instead. \
-    This method will be renamed to translated_local in gdnative 0.11."]
+    This method will be renamed to translated_local in gdnative 0.12."]
     #[inline]
     pub fn translated(&self, translation: Vector3) -> Self {
         Self {
@@ -119,17 +130,18 @@ impl Transform {
     /// affine_inverse for transforms with scaling).
     #[inline]
     pub fn inverse(&self) -> Self {
+        let basis = self.basis.transposed();
         Transform {
-            basis: self.basis.transposed(),
-            origin: self.basis.xform(-self.origin),
+            basis,
+            origin: basis.xform(-self.origin),
         }
     }
 
     /// Returns the inverse of the transform, under the assumption that the
     /// transformation is composed of rotation, scaling and translation.
     #[inline]
     pub fn affine_inverse(&self) -> Self {
-        let basis_inv = self.basis.inverted();
+        let basis_inv = self.basis.inverse();
         let origin_inv = basis_inv.xform(-self.origin);
 
         Self {
@@ -150,12 +162,14 @@ impl Transform {
         } * (*self)
     }
 
+    /*
     /// Returns the rotated transform around the given axis by the given angle (in radians),
     /// using matrix multiplication. The axis must be a normalized vector.
     #[inline]
     fn rotate(&mut self, axis: Vector3, phi: f32) {
         *self = self.rotated(axis, phi);
     }
+    */
 
     /// Returns a copy of the transform rotated such that its -Z axis points
     /// towards the target position.
@@ -189,7 +203,7 @@ impl Transform {
     /// In-place translates the transform by the given offset, relative to
     /// the transform's basis vectors.
     #[inline]
-    fn translate_withbasis(&mut self, translation: Vector3) {
+    fn translate_global(&mut self, translation: Vector3) {
         // Note: Godot source uses origin + basis dot translation,
         // but self.translate() uses only origin + translation
         self.origin.x += self.basis.elements[0].dot(translation);
@@ -204,7 +218,7 @@ impl Transform {
     #[inline]
     pub fn translated_global(&self, translation: Vector3) -> Self {
         let mut copy = *self;
-        copy.translate_withbasis(translation);
+        copy.translate_global(translation);
         copy
     }
 
@@ -356,6 +370,23 @@ mod tests {
         assert!(expected.is_equal_approx(&t))
     }
 
+    /*
+    #[test]
+    fn inverse_is_sane() {
+        let t = test_inputs().0.inverse();
+        let expected = Transform::from_basis_origin(
+            // Fix values
+            Vector3::new(0.309725, -0.66022015, 3.9329607),
+            Vector3::new(-0.57629496, 1.8808193, 0.3611141),
+            Vector3::new(-0.47722515, -0.14864945, 0.012628445),
+            Vector3::new(-0.7398631, 0.0425314, 0.03682696),
+        );
+
+        println!("TF:  {t:?}");
+        assert!(expected.is_equal_approx(&t))
+    }
+    */
+
     #[test]
     fn orthonormalization_is_sane() {
         // Godot reports: