Pass Transform2D, Transform3D, Basis by-ref

Author: joriskleiber

godot-core/src/builtin/basis.rs

@@ -162,15 +162,15 @@ impl Basis {
     }
 
     /// Creates a `[Vector3; 3]` with the columns of the `Basis`.
-    pub fn to_cols(self) -> [Vector3; 3] {
+    pub fn to_cols(&self) -> [Vector3; 3] {
         self.transposed().rows
     }
 
     /// Creates a [`Quaternion`] representing the same rotation as this basis.
     ///
     /// _Godot equivalent: `Basis.get_rotation_quaternion()`_
     #[doc(alias = "get_rotation_quaternion")]
-    pub fn to_quat(self) -> Quaternion {
+    pub fn to_quat(&self) -> Quaternion {
         RQuat::from_mat3(&self.orthonormalized().to_glam()).to_front()
     }
 
@@ -211,7 +211,7 @@ impl Basis {
     /// The order of the angles are given by `order`.
     ///
     /// _Godot equivalent: `Basis.get_euler()`_
-    pub fn to_euler(self, order: EulerOrder) -> Vector3 {
+    pub fn to_euler(&self, order: EulerOrder) -> Vector3 {
         use glam::swizzles::Vec3Swizzles as _;
 
         let col_a = self.col_a().to_glam();
@@ -346,23 +346,23 @@ impl Basis {
     ///
     /// _Godot equivalent: `Basis.scaled()`_
     #[must_use]
-    pub fn scaled(self, scale: Vector3) -> Self {
-        Self::from_diagonal(scale.x, scale.y, scale.z) * self
+    pub fn scaled(&self, scale: Vector3) -> Self {
+        Self::from_diagonal(scale.x, scale.y, scale.z) * (*self)
     }
 
     /// Returns the inverse of the matrix.
     ///
     /// _Godot equivalent: `Basis.inverse()`_
     #[must_use]
-    pub fn inverse(self) -> Basis {
+    pub fn inverse(&self) -> Basis {
         self.glam(|mat| mat.inverse())
     }
 
     /// Returns the transposed version of the matrix.
     ///
     /// _Godot equivalent: `Basis.transposed()`_
     #[must_use]
-    pub fn transposed(self) -> Self {
+    pub fn transposed(&self) -> Self {
         Self::from_cols(self.rows[0], self.rows[1], self.rows[2])
     }
 
@@ -376,7 +376,7 @@ impl Basis {
     ///
     /// _Godot equivalent: `Basis.orthonormalized()`_
     #[must_use]
-    pub fn orthonormalized(self) -> Self {
+    pub fn orthonormalized(&self) -> Self {
         assert!(
             !self.determinant().is_zero_approx(),
             "Determinant should not be zero."
@@ -401,16 +401,16 @@ impl Basis {
     ///
     /// _Godot equivalent: `Basis.rotated()`_
     #[must_use]
-    pub fn rotated(self, axis: Vector3, angle: real) -> Self {
-        Self::from_axis_angle(axis, angle) * self
+    pub fn rotated(&self, axis: Vector3, angle: real) -> Self {
+        Self::from_axis_angle(axis, angle) * (*self)
     }
 
     /// Assuming that the matrix is a proper rotation matrix, slerp performs
     /// a spherical-linear interpolation with another rotation matrix.
     ///
     /// _Godot equivalent: `Basis.slerp()`_
     #[must_use]
-    pub fn slerp(self, other: Self, weight: real) -> Self {
+    pub fn slerp(&self, other: &Self, weight: real) -> Self {
         let from = self.to_quat();
         let to = other.to_quat();
 

godot-core/src/builtin/transform2d.rs

@@ -136,7 +136,8 @@ impl Transform2D {
     }
 
     /// Create a [`Basis2D`] from the first two columns of the transform.
-    fn to_basis(self) -> Basis2D {
+    #[allow(clippy::wrong_self_convention)]
+    fn to_basis(&self) -> Basis2D {
         Basis2D::from_cols(self.a, self.b)
     }
 
@@ -145,7 +146,7 @@ impl Transform2D {
     ///
     /// _Godot equivalent: `Transform2D.affine_inverse()`_
     #[must_use]
-    pub fn affine_inverse(self) -> Self {
+    pub fn affine_inverse(&self) -> Self {
         self.glam(|aff| aff.inverse())
     }
 
@@ -177,7 +178,7 @@ impl Transform2D {
     ///
     /// _Godot equivalent: `Transform2D.interpolate_with()`_
     #[must_use]
-    pub fn interpolate_with(self, other: Self, weight: real) -> Self {
+    pub fn interpolate_with(&self, other: &Self, weight: real) -> Self {
         Self::from_angle_scale_skew_origin(
             self.rotation().lerp_angle(other.rotation(), weight),
             self.scale().lerp(other.scale(), weight),
@@ -199,7 +200,7 @@ impl Transform2D {
     ///
     /// _Godot equivalent: `Transform2D.orthonormalized()`_
     #[must_use]
-    pub fn orthonormalized(self) -> Self {
+    pub fn orthonormalized(&self) -> Self {
         Self::from_basis_origin(self.basis().orthonormalized(), self.origin)
     }
 
@@ -210,8 +211,8 @@ impl Transform2D {
     ///
     /// _Godot equivalent: `Transform2D.rotated()`_
     #[must_use]
-    pub fn rotated(self, angle: real) -> Self {
-        Self::from_angle(angle) * self
+    pub fn rotated(&self, angle: real) -> Self {
+        Self::from_angle(angle) * (*self)
     }
 
     /// Returns a copy of the transform rotated by the given `angle` (in radians).
@@ -221,8 +222,8 @@ impl Transform2D {
     ///
     /// _Godot equivalent: `Transform2D.rotated_local()`_
     #[must_use]
-    pub fn rotated_local(self, angle: real) -> Self {
-        self * Self::from_angle(angle)
+    pub fn rotated_local(&self, angle: real) -> Self {
+        (*self) * Self::from_angle(angle)
     }
 
     /// Returns a copy of the transform scaled by the given scale factor.
@@ -232,7 +233,7 @@ impl Transform2D {
     ///
     /// _Godot equivalent: `Transform2D.scaled()`_
     #[must_use]
-    pub fn scaled(self, scale: Vector2) -> Self {
+    pub fn scaled(&self, scale: Vector2) -> Self {
         let mut basis = self.to_basis();
         basis.set_row_a(basis.row_a() * scale.x);
         basis.set_row_b(basis.row_b() * scale.y);
@@ -246,7 +247,7 @@ impl Transform2D {
     ///
     /// _Godot equivalent: `Transform2D.scaled_local()`_
     #[must_use]
-    pub fn scaled_local(self, scale: Vector2) -> Self {
+    pub fn scaled_local(&self, scale: Vector2) -> Self {
         Self::from_basis_origin(self.basis().scaled(scale), self.origin)
     }
 
@@ -257,7 +258,7 @@ impl Transform2D {
     ///
     /// _Godot equivalent: `Transform2D.translated()`_
     #[must_use]
-    pub fn translated(self, offset: Vector2) -> Self {
+    pub fn translated(&self, offset: Vector2) -> Self {
         Self::from_cols(self.a, self.b, self.origin + offset)
     }
 
@@ -268,7 +269,7 @@ impl Transform2D {
     ///
     /// _Godot equivalent: `Transform2D.translated()`_
     #[must_use]
-    pub fn translated_local(self, offset: Vector2) -> Self {
+    pub fn translated_local(&self, offset: Vector2) -> Self {
         Self::from_cols(self.a, self.b, self.origin + (self.to_basis() * offset))
     }
 
@@ -670,7 +671,7 @@ mod test {
         );
 
         let interpolated: Transform2D =
-            Transform2D::IDENTITY.interpolate_with(rotate_scale_skew_pos, 0.5);
+            Transform2D::IDENTITY.interpolate_with(&rotate_scale_skew_pos, 0.5);
         assert_eq_approx!(interpolated.origin, rotate_scale_skew_pos_halfway.origin);
         assert_eq_approx!(
             interpolated.rotation(),
@@ -680,7 +681,7 @@ mod test {
         assert_eq_approx!(interpolated.skew(), rotate_scale_skew_pos_halfway.skew());
         assert_eq_approx!(interpolated, rotate_scale_skew_pos_halfway);
 
-        let interpolated = rotate_scale_skew_pos.interpolate_with(Transform2D::IDENTITY, 0.5);
+        let interpolated = rotate_scale_skew_pos.interpolate_with(&Transform2D::IDENTITY, 0.5);
         assert_eq_approx!(interpolated, rotate_scale_skew_pos_halfway);
     }
 

godot-core/src/builtin/transform3d.rs

@@ -81,7 +81,7 @@ impl Transform3D {
     /// the projection matrix.
     ///
     /// _Godot equivalent: `Transform3D(Projection from)`_
-    pub fn from_projection(proj: Projection) -> Self {
+    pub fn from_projection(proj: &Projection) -> Self {
         let a = Vector3::new(proj.cols[0].x, proj.cols[0].y, proj.cols[0].z);
         let b = Vector3::new(proj.cols[1].x, proj.cols[1].y, proj.cols[1].z);
         let c = Vector3::new(proj.cols[2].x, proj.cols[2].y, proj.cols[2].z);
@@ -114,14 +114,14 @@ impl Transform3D {
     /// Returns the inverse of the transform, under the assumption that the
     /// transformation is composed of rotation, scaling and translation.
     #[must_use]
-    pub fn affine_inverse(self) -> Self {
+    pub fn affine_inverse(&self) -> Self {
         self.glam(|aff| aff.inverse())
     }
 
     /// Returns a transform interpolated between this transform and another by
     /// a given weight (on the range of 0.0 to 1.0).
     #[must_use]
-    pub fn interpolate_with(self, other: Self, weight: real) -> Self {
+    pub fn interpolate_with(&self, other: &Self, weight: real) -> Self {
         let src_scale = self.basis.scale();
         let src_rot = self.basis.to_quat().normalized();
         let src_loc = self.origin;
@@ -151,7 +151,7 @@ impl Transform3D {
     /// See [`Basis::new_looking_at()`] for more information.
     #[cfg(before_api = "4.1")]
     #[must_use]
-    pub fn looking_at(self, target: Vector3, up: Vector3) -> Self {
+    pub fn looking_at(&self, target: Vector3, up: Vector3) -> Self {
         Self {
             basis: Basis::new_looking_at(target - self.origin, up),
             origin: self.origin,
@@ -160,7 +160,7 @@ impl Transform3D {
 
     #[cfg(since_api = "4.1")]
     #[must_use]
-    pub fn looking_at(self, target: Vector3, up: Vector3, use_model_front: bool) -> Self {
+    pub fn looking_at(&self, target: Vector3, up: Vector3, use_model_front: bool) -> Self {
         Self {
             basis: Basis::new_looking_at(target - self.origin, up, use_model_front),
             origin: self.origin,
@@ -172,7 +172,7 @@ impl Transform3D {
     ///
     /// _Godot equivalent: Transform3D.orthonormalized()_
     #[must_use]
-    pub fn orthonormalized(self) -> Self {
+    pub fn orthonormalized(&self) -> Self {
         Self {
             basis: self.basis.orthonormalized(),
             origin: self.origin,
@@ -186,7 +186,7 @@ impl Transform3D {
     ///
     /// _Godot equivalent: `Transform2D.rotated()`_
     #[must_use]
-    pub fn rotated(self, axis: Vector3, angle: real) -> Self {
+    pub fn rotated(&self, axis: Vector3, angle: real) -> Self {
         let rotation = Basis::from_axis_angle(axis, angle);
         Self {
             basis: rotation * self.basis,
@@ -200,7 +200,7 @@ impl Transform3D {
     ///
     /// _Godot equivalent: `Transform2D.rotated_local()`_
     #[must_use]
-    pub fn rotated_local(self, axis: Vector3, angle: real) -> Self {
+    pub fn rotated_local(&self, axis: Vector3, angle: real) -> Self {
         Self {
             basis: self.basis * Basis::from_axis_angle(axis, angle),
             origin: self.origin,
@@ -214,7 +214,7 @@ impl Transform3D {
     ///
     /// _Godot equivalent: `Transform2D.scaled()`_
     #[must_use]
-    pub fn scaled(self, scale: Vector3) -> Self {
+    pub fn scaled(&self, scale: Vector3) -> Self {
         Self {
             basis: Basis::from_scale(scale) * self.basis,
             origin: self.origin * scale,
@@ -228,7 +228,7 @@ impl Transform3D {
     ///
     /// _Godot equivalent: `Transform2D.scaled_local()`_
     #[must_use]
-    pub fn scaled_local(self, scale: Vector3) -> Self {
+    pub fn scaled_local(&self, scale: Vector3) -> Self {
         Self {
             basis: self.basis * Basis::from_scale(scale),
             origin: self.origin,
@@ -242,7 +242,7 @@ impl Transform3D {
     ///
     /// _Godot equivalent: `Transform2D.translated()`_
     #[must_use]
-    pub fn translated(self, offset: Vector3) -> Self {
+    pub fn translated(&self, offset: Vector3) -> Self {
         Self {
             basis: self.basis,
             origin: self.origin + offset,
@@ -256,7 +256,7 @@ impl Transform3D {
     ///
     /// _Godot equivalent: `Transform2D.translated()`_
     #[must_use]
-    pub fn translated_local(self, offset: Vector3) -> Self {
+    pub fn translated_local(&self, offset: Vector3) -> Self {
         Self {
             basis: self.basis,
             origin: self.origin + (self.basis * offset),

itest/rust/src/builtin_tests/geometry/basis_test.rs

@@ -122,12 +122,12 @@ fn basis_equiv() {
 
     #[rustfmt::skip]
     let mappings_basis = [
-        ("inverse",         inner.inverse(),                      outer.inverse()                     ),
-        ("transposed",      inner.transposed(),                   outer.transposed()                  ),
-        ("orthonormalized", inner.orthonormalized(),              outer.orthonormalized()             ),
-        ("rotated",         inner.rotated(vec.normalized(), 0.1), outer.rotated(vec.normalized(), 0.1)),
-        ("scaled",          inner.scaled(vec),                    outer.scaled(vec)                   ),
-        ("slerp",           inner.slerp(Basis::IDENTITY, 0.5),    outer.slerp(Basis::IDENTITY, 0.5)   ),
+        ("inverse",         inner.inverse(),                      outer.inverse()                      ),
+        ("transposed",      inner.transposed(),                   outer.transposed()                   ),
+        ("orthonormalized", inner.orthonormalized(),              outer.orthonormalized()              ),
+        ("rotated",         inner.rotated(vec.normalized(), 0.1), outer.rotated(vec.normalized(), 0.1) ),
+        ("scaled",          inner.scaled(vec),                    outer.scaled(vec)                    ),
+        ("slerp",           inner.slerp(Basis::IDENTITY, 0.5),    outer.slerp(&Basis::IDENTITY, 0.5)   ),
     ];
     for (name, inner, outer) in mappings_basis {
         assert_eq_approx!(inner, outer, "function: {name}\n");

itest/rust/src/builtin_tests/geometry/transform2d_test.rs

@@ -26,15 +26,15 @@ fn transform2d_equiv() {
 
     #[rustfmt::skip]
         let mappings_transform = [
-        ("affine_inverse",   inner.affine_inverse(),                             outer.affine_inverse()                            ),
-        ("orthonormalized",  inner.orthonormalized(),                            outer.orthonormalized()                           ),
-        ("rotated",          inner.rotated(1.0),                                 outer.rotated(1.0)                                ),
-        ("rotated_local",    inner.rotated_local(1.0),                           outer.rotated_local(1.0)                          ),
-        ("scaled",           inner.scaled(vec),                                  outer.scaled(vec)                                 ),
-        ("scaled_local",     inner.scaled_local(vec),                            outer.scaled_local(vec)                           ),
-        ("translated",       inner.translated(vec),                              outer.translated(vec)                             ),
-        ("translated_local", inner.translated_local(vec),                        outer.translated_local(vec)                       ),
-        ("interpolate_with", inner.interpolate_with(Transform2D::IDENTITY, 0.5), outer.interpolate_with(Transform2D::IDENTITY, 0.5))
+        ("affine_inverse",   inner.affine_inverse(),                             outer.affine_inverse()                             ),
+        ("orthonormalized",  inner.orthonormalized(),                            outer.orthonormalized()                            ),
+        ("rotated",          inner.rotated(1.0),                                 outer.rotated(1.0)                                 ),
+        ("rotated_local",    inner.rotated_local(1.0),                           outer.rotated_local(1.0)                           ),
+        ("scaled",           inner.scaled(vec),                                  outer.scaled(vec)                                  ),
+        ("scaled_local",     inner.scaled_local(vec),                            outer.scaled_local(vec)                            ),
+        ("translated",       inner.translated(vec),                              outer.translated(vec)                              ),
+        ("translated_local", inner.translated_local(vec),                        outer.translated_local(vec)                        ),
+        ("interpolate_with", inner.interpolate_with(Transform2D::IDENTITY, 0.5), outer.interpolate_with(&Transform2D::IDENTITY, 0.5))
     ];
     for (name, inner, outer) in mappings_transform {
         assert_eq_approx!(inner, outer, "function: {name}\n");

itest/rust/src/builtin_tests/geometry/transform3d_test.rs

@@ -29,15 +29,15 @@ fn transform3d_equiv() {
 
     #[rustfmt::skip]
     let mappings_transform = [
-        ("affine_inverse",   inner.affine_inverse(),                             outer.affine_inverse()                            ),
-        ("orthonormalized",  inner.orthonormalized(),                            outer.orthonormalized()                           ),
-        ("rotated",          inner.rotated(vec.normalized(), 1.0),               outer.rotated(vec.normalized(), 1.0)              ),
-        ("rotated_local",    inner.rotated_local(vec.normalized(), 1.0),         outer.rotated_local(vec.normalized(), 1.0)        ),
-        ("scaled",           inner.scaled(vec),                                  outer.scaled(vec)                                 ),
-        ("scaled_local",     inner.scaled_local(vec),                            outer.scaled_local(vec)                           ),
-        ("translated",       inner.translated(vec),                              outer.translated(vec)                             ),
-        ("translated_local", inner.translated_local(vec),                        outer.translated_local(vec)                       ),
-        ("interpolate_with", inner.interpolate_with(Transform3D::IDENTITY, 0.5), outer.interpolate_with(Transform3D::IDENTITY, 0.5))
+        ("affine_inverse",   inner.affine_inverse(),                             outer.affine_inverse()                             ),
+        ("orthonormalized",  inner.orthonormalized(),                            outer.orthonormalized()                            ),
+        ("rotated",          inner.rotated(vec.normalized(), 1.0),               outer.rotated(vec.normalized(), 1.0)               ),
+        ("rotated_local",    inner.rotated_local(vec.normalized(), 1.0),         outer.rotated_local(vec.normalized(), 1.0)         ),
+        ("scaled",           inner.scaled(vec),                                  outer.scaled(vec)                                  ),
+        ("scaled_local",     inner.scaled_local(vec),                            outer.scaled_local(vec)                            ),
+        ("translated",       inner.translated(vec),                              outer.translated(vec)                              ),
+        ("translated_local", inner.translated_local(vec),                        outer.translated_local(vec)                        ),
+        ("interpolate_with", inner.interpolate_with(Transform3D::IDENTITY, 0.5), outer.interpolate_with(&Transform3D::IDENTITY, 0.5))
     ];
     for (name, inner, outer) in mappings_transform {
         assert_eq_approx!(inner, outer, "function: {name}\n");