Repository: bitshifter/glam-rs
Pull request #176 (2021-05-09 10:31:30)

Undo renaming of transform types and deprecate them.
* `Affine2`, `DAffine2`, `Affine3A` and `DAffine3` are part of the core library
* `TransformRT` and `TransformSRT` are deprecated and will move to a separate experimental crate.
* Removed `PartialOrd` trait implementation for all types
* Removed problematic `From` traits for `Quat`
* Fixed a lot of clippy lints


Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index eec8928..21d958c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,9 +9,18 @@ The format is based on [Keep a Changelog], and this project adheres to
 
 ### Added
 
-* Added 3D affine transform types `Affine3` and `DAffine3`. These are more
-  efficient than using `Mat4` and `DMat4` respectively when working with affine
-  transforms.
+* Added 3D affine transform types `Affine3A` and `DAffine3`. These are more
+  efficient than using `Mat4` and `DMat4` respectively when working with 3D
+  affine transforms.
+* Added 2D affine transform types `Affine2` and `DAffine2`. These are more
+  efficient than using `Mat3` and `DMat3` respectively when working with 2D
+  affine transforms.
+
+### Changed
+
+* Deprecated `TransformSRT` and `TransformRT` which are under the
+  `transform-types` feature. These will be moved to a separate experimental
+  crate.
 
 ## [0.14.0] - 2021-04-09
 
@@ -505,7 +514,8 @@ The format is based on [Keep a Changelog], and this project adheres to
 
 [Keep a Changelog]: https://keepachangelog.com/
 [Semantic Versioning]: https://semver.org/spec/v2.0.0.html
-[Unreleased]: https://github.com/bitshifter/glam-rs/compare/0.13.1...HEAD
+[Unreleased]: https://github.com/bitshifter/glam-rs/compare/0.14.0...HEAD
+[0.14.0]: https://github.com/bitshifter/glam-rs/compare/0.13.1...0.14.0
 [0.13.1]: https://github.com/bitshifter/glam-rs/compare/0.13.0...0.13.1
 [0.13.0]: https://github.com/bitshifter/glam-rs/compare/0.12.0...0.13.0
 [0.12.0]: https://github.com/bitshifter/glam-rs/compare/0.11.3...0.12.0
diff --git a/Cargo.toml b/Cargo.toml
index 9de05a0..cdf3744 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,8 +29,7 @@ glam-assert = []
 # this is primarily for testing the fallback implementation
 scalar-math = []
 
-# trying out transform types instead of matrices but they are generally slower
-# at everything except for inverse. They are 16 bytes smaller than a Mat4.
+# deprecated and will move to a separate crate
 transform-types = []
 
 # libm is required when building no_std
@@ -68,12 +67,10 @@ harness = false
 [[bench]]
 name = "affine2"
 harness = false
-required-features = ["transform-types"]
 
 [[bench]]
 name = "affine3"
 harness = false
-required-features = ["transform-types"]
 
 [[bench]]
 name = "mat4"
diff --git a/benches/transform.rs b/benches/transform.rs
index 0155b3f..c14ce2e 100644
--- a/benches/transform.rs
+++ b/benches/transform.rs
@@ -1,130 +1,132 @@
+#![allow(deprecated)]
+
 #[path = "support/macros.rs"]
 #[macro_use]
 mod macros;
 mod support;
 
 use criterion::{criterion_group, criterion_main, Criterion};
-use glam::{Isometry3A, Transform3A};
+use glam::{TransformRT, TransformSRT};
 use std::ops::Mul;
 use support::*;
 
-fn random_transform3a(rng: &mut PCG32) -> Transform3A {
-    Transform3A::from_scale_rotation_translation(
+fn random_transformsrt(rng: &mut PCG32) -> TransformSRT {
+    TransformSRT::from_scale_rotation_translation(
         random_nonzero_vec3(rng),
         random_quat(rng),
         random_vec3(rng),
     )
 }
 
-fn random_isometry3a(rng: &mut PCG32) -> Isometry3A {
-    Isometry3A::from_rotation_translation(random_quat(rng), random_vec3(rng))
+fn random_transformrt(rng: &mut PCG32) -> TransformRT {
+    TransformRT::from_rotation_translation(random_quat(rng), random_vec3(rng))
 }
 
 bench_unop!(
-    isometry3a_inverse,
-    "isometry3a inverse",
+    transformrt_inverse,
+    "TransformRT inverse",
     op => inverse,
-    from => random_isometry3a
+    from => random_transformrt
 );
 
 bench_unop!(
-    transform3a_inverse,
-    "transform3a inverse",
+    transformsrt_inverse,
+    "TransformSRT inverse",
     op => inverse,
-    from => random_transform3a
+    from => random_transformsrt
 );
 
 bench_binop!(
-    isometry3a_transform_point3,
-    "isometry3a transform point3",
+    transformrt_transform_point3,
+    "TransformRT transform point3",
     op => transform_point3,
-    from1 => random_isometry3a,
+    from1 => random_transformrt,
     from2 => random_vec3
 );
 
 bench_binop!(
-    isometry3a_transform_point3a,
-    "isometry3a transform point3a",
+    transformrt_transform_point3a,
+    "TransformRT transform point3a",
     op => transform_point3a,
-    from1 => random_isometry3a,
+    from1 => random_transformrt,
     from2 => random_vec3a
 );
 
 bench_binop!(
-    isometry3a_transform_vector3,
-    "isometry3a transform vector3",
+    transformrt_transform_vector3,
+    "TransformRT transform vector3",
     op => transform_vector3,
-    from1 => random_isometry3a,
+    from1 => random_transformrt,
     from2 => random_vec3
 );
 
 bench_binop!(
-    isometry3a_transform_vector3a,
-    "isometry3a transform vector3a",
+    transformrt_transform_vector3a,
+    "TransformRT transform vector3a",
     op => transform_vector3a,
-    from1 => random_isometry3a,
+    from1 => random_transformrt,
     from2 => random_vec3a
 );
 
 bench_binop!(
-    transform3a_transform_point3,
-    "transform3a transform point3",
+    transformsrt_transform_point3,
+    "TransformSRT transform point3",
     op => transform_point3,
-    from1 => random_transform3a,
+    from1 => random_transformsrt,
     from2 => random_vec3
 );
 
 bench_binop!(
-    transform3a_transform_point3a,
-    "transform3a transform point3a",
+    transformsrt_transform_point3a,
+    "TransformSRT transform point3a",
     op => transform_point3a,
-    from1 => random_transform3a,
+    from1 => random_transformsrt,
     from2 => random_vec3a
 );
 
 bench_binop!(
-    transform3a_transform_vector3,
-    "transform3a transform vector3",
+    transformsrt_transform_vector3,
+    "TransformSRT transform vector3",
     op => transform_vector3,
-    from1 => random_transform3a,
+    from1 => random_transformsrt,
     from2 => random_vec3
 );
 
 bench_binop!(
-    transform3a_transform_vector3a,
-    "transform3a transform vector3a",
+    transformsrt_transform_vector3a,
+    "TransformSRT transform vector3a",
     op => transform_vector3a,
-    from1 => random_transform3a,
+    from1 => random_transformsrt,
     from2 => random_vec3a
 );
 bench_binop!(
-    transform3a_mul_transform3a,
-    "transform3a mul transform3a",
+    transformsrt_mul_transformsrt,
+    "TransformSRT mul TransformSRT",
     op => mul,
-    from => random_transform3a
+    from => random_transformsrt
 );
 
 bench_binop!(
-    isometry3a_mul_isometry3a,
-    "isometry3a mul isometry3a",
+    transformrt_mul_transformrt,
+    "TransformRT mul TransformRT",
     op => mul,
-    from => random_isometry3a
+    from => random_transformrt
 );
 
 criterion_group!(
     benches,
-    isometry3a_inverse,
-    isometry3a_mul_isometry3a,
-    isometry3a_transform_point3,
-    isometry3a_transform_point3a,
-    isometry3a_transform_vector3,
-    isometry3a_transform_vector3a,
-    transform3a_inverse,
-    transform3a_mul_transform3a,
-    transform3a_transform_point3,
-    transform3a_transform_point3a,
-    transform3a_transform_vector3,
-    transform3a_transform_vector3a,
+    transformrt_inverse,
+    transformrt_mul_transformrt,
+    transformrt_transform_point3,
+    transformrt_transform_point3a,
+    transformrt_transform_vector3,
+    transformrt_transform_vector3a,
+    transformsrt_inverse,
+    transformsrt_mul_transformsrt,
+    transformsrt_transform_point3,
+    transformsrt_transform_point3a,
+    transformsrt_transform_vector3,
+    transformsrt_transform_vector3a,
 );
 
 criterion_main!(benches);
diff --git a/src/core/sse2/float.rs b/src/core/sse2/float.rs
index 8169371..d2fa304 100644
--- a/src/core/sse2/float.rs
+++ b/src/core/sse2/float.rs
@@ -39,21 +39,21 @@ _ps_const_ty!(
     PS_SIN_COEFFICIENTS0,
     f32x4,
     -0.16666667,
-    0.0083333310,
+    0.008_333_331,
     -0.00019840874,
-    2.7525562e-06
+    2.752_556_2e-6
 );
 _ps_const_ty!(
     PS_SIN_COEFFICIENTS1,
     f32x4,
-    -2.3889859e-08,
-    -0.16665852,    /*Est1*/
-    0.0083139502,   /*Est2*/
-    -0.00018524670  /*Est3*/
+    -2.388_985_9e-8,
+    -0.16665852,      /*Est1*/
+    0.008_313_95,     /*Est2*/
+    -0.000_185_246_7  /*Est3*/
 );
 _ps_const_ty!(PS_ONE, f32x4, 1.0);
 _ps_const_ty!(PS_TWO_PI, f32x4, core::f32::consts::PI * 2.0);
-_ps_const_ty!(PS_RECIPROCAL_TWO_PI, f32x4, 0.159154943);
+_ps_const_ty!(PS_RECIPROCAL_TWO_PI, f32x4, 0.159_154_94);
 
 #[inline]
 pub(crate) unsafe fn m128_abs(v: __m128) -> __m128 {
diff --git a/src/core/sse2/vector.rs b/src/core/sse2/vector.rs
index 738b761..5c260d2 100644
--- a/src/core/sse2/vector.rs
+++ b/src/core/sse2/vector.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::many_single_char_names)]
+
 #[cfg(target_arch = "x86")]
 use core::arch::x86::*;
 #[cfg(target_arch = "x86_64")]
diff --git a/src/features/impl_mint.rs b/src/features/impl_mint.rs
index 43e1539..7e4c517 100644
--- a/src/features/impl_mint.rs
+++ b/src/features/impl_mint.rs
@@ -326,7 +326,7 @@ mod test {
                     s: 4.0,
                 };
                 let g = $quat::from(m);
-                assert_eq!(g, $quat::from((1.0, 2.0, 3.0, 4.0)));
+                assert_eq!(g, $quat::from_xyzw(1.0, 2.0, 3.0, 4.0));
                 assert_eq!(m, g.into());
             }
 
diff --git a/src/lib.rs b/src/lib.rs
index d2bb8bb..03b2f28 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -190,14 +190,18 @@ The minimum supported version of Rust for `glam` is `1.45.0`.
 
 #[macro_use]
 mod macros;
+
 #[macro_use]
 mod vec;
 
 #[doc(hidden)]
 pub mod cast;
 
+mod affine2;
+mod affine3;
 mod core;
 mod euler;
+mod features;
 mod mat2;
 mod mat3;
 mod mat4;
@@ -207,14 +211,9 @@ mod vec3;
 mod vec4;
 mod vec_mask;
 
-mod features;
 #[cfg(feature = "spirv-std")]
 mod spirv;
 
-#[cfg(feature = "transform-types")]
-mod affine2;
-#[cfg(feature = "transform-types")]
-mod affine3;
 #[cfg(feature = "transform-types")]
 mod transform;
 
@@ -229,9 +228,7 @@ pub use self::bool::*;
 
 /** `f32` vector, quaternion and matrix types. */
 pub mod f32 {
-    #[cfg(feature = "transform-types")]
     pub use super::affine2::Affine2;
-    #[cfg(feature = "transform-types")]
     pub use super::affine3::Affine3A;
     pub use super::mat2::{mat2, Mat2};
     pub use super::mat3::{mat3, mat3a, Mat3, Mat3A};
@@ -242,15 +239,14 @@ pub mod f32 {
     pub use super::vec4::{vec4, Vec4};
 
     #[cfg(feature = "transform-types")]
-    pub use super::transform::{Isometry3A, Transform3A};
+    #[allow(deprecated)]
+    pub use super::transform::{TransformRT, TransformSRT};
 }
 pub use self::f32::*;
 
 /** `f64` vector, quaternion and matrix types. */
 pub mod f64 {
-    #[cfg(feature = "transform-types")]
     pub use super::affine2::DAffine2;
-    #[cfg(feature = "transform-types")]
     pub use super::affine3::DAffine3;
     pub use super::mat2::{dmat2, DMat2};
     pub use super::mat3::{dmat3, DMat3};
diff --git a/src/mat2.rs b/src/mat2.rs
index 3c85552..dcaab32 100644
--- a/src/mat2.rs
+++ b/src/mat2.rs
@@ -5,10 +5,7 @@ use crate::core::{
 use crate::{DMat3, DVec2, Mat3, Vec2};
 #[cfg(not(target_arch = "spirv"))]
 use core::fmt;
-use core::{
-    cmp::Ordering,
-    ops::{Add, Deref, DerefMut, Mul, Sub},
-};
+use core::ops::{Add, Deref, DerefMut, Mul, Sub};
 
 #[cfg(all(
     target_arch = "x86",
@@ -238,13 +235,6 @@ macro_rules! impl_mat2_traits {
             }
         }
 
-        impl PartialOrd for $mat2 {
-            #[inline]
-            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-                self.as_ref().partial_cmp(other.as_ref())
-            }
-        }
-
         impl AsRef<[$t; 4]> for $mat2 {
             #[inline(always)]
             fn as_ref(&self) -> &[$t; 4] {
diff --git a/src/mat3.rs b/src/mat3.rs
index bbd1d1e..9414e59 100644
--- a/src/mat3.rs
+++ b/src/mat3.rs
@@ -5,10 +5,7 @@ use crate::core::{
 use crate::{DMat2, DMat4, DQuat, DVec2, DVec3, EulerRot, Mat2, Mat4, Quat, Vec2, Vec3, Vec3A};
 #[cfg(not(target_arch = "spirv"))]
 use core::fmt;
-use core::{
-    cmp::Ordering,
-    ops::{Add, Deref, DerefMut, Mul, Sub},
-};
+use core::ops::{Add, Deref, DerefMut, Mul, Sub};
 
 #[cfg(all(
     target_arch = "x86",
@@ -497,13 +494,6 @@ macro_rules! impl_mat3_traits_unsafe {
                 unsafe { &mut *(self as *mut Self as *mut [$t; 9]) }
             }
         }
-
-        impl PartialOrd for $mat3 {
-            #[inline]
-            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-                self.as_ref().partial_cmp(other.as_ref())
-            }
-        }
     };
 }
 
diff --git a/src/mat4.rs b/src/mat4.rs
index 73b481b..f888dc3 100644
--- a/src/mat4.rs
+++ b/src/mat4.rs
@@ -22,10 +22,7 @@ use core::arch::x86_64::*;
 
 #[cfg(not(target_arch = "spirv"))]
 use core::fmt;
-use core::{
-    cmp::Ordering,
-    ops::{Add, Deref, DerefMut, Mul, Sub},
-};
+use core::ops::{Add, Deref, DerefMut, Mul, Sub};
 
 #[cfg(feature = "std")]
 use std::iter::{Product, Sum};
@@ -587,12 +584,6 @@ macro_rules! impl_mat4_traits {
             }
         }
 
-        impl PartialOrd for $mat4 {
-            #[inline]
-            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-                self.as_ref().partial_cmp(other.as_ref())
-            }
-        }
         impl AsRef<[$t; 16]> for $mat4 {
             #[inline]
             fn as_ref(&self) -> &[$t; 16] {
@@ -731,6 +722,7 @@ impl Mat4 {
     /// This is the equivalent of multiplying the `Vec3A` as a 4D vector where `w` is `1.0`.
     #[inline(always)]
     pub fn transform_point3a(&self, other: Vec3A) -> Vec3A {
+        #[allow(clippy::useless_conversion)]
         Vec3A(self.0.transform_float4_as_point3(other.0.into()).into())
     }
 
@@ -739,6 +731,7 @@ impl Mat4 {
     /// This is the equivalent of multiplying the `Vec3A` as a 4D vector where `w` is `0.0`.
     #[inline(always)]
     pub fn transform_vector3a(&self, other: Vec3A) -> Vec3A {
+        #[allow(clippy::useless_conversion)]
         Vec3A(self.0.transform_float4_as_vector3(other.0.into()).into())
     }
 
diff --git a/src/quat.rs b/src/quat.rs
index 9208fb4..9d4f344 100644
--- a/src/quat.rs
+++ b/src/quat.rs
@@ -24,21 +24,21 @@ use core::arch::x86_64::*;
 
 #[cfg(not(target_arch = "spirv"))]
 use core::fmt;
-use core::{
-    cmp::Ordering,
-    ops::{Add, Deref, Div, Mul, MulAssign, Neg, Sub},
-};
+use core::ops::{Add, Deref, Div, Mul, MulAssign, Neg, Sub};
 
 #[cfg(feature = "std")]
 use std::iter::{Product, Sum};
 
 macro_rules! impl_quat_methods {
-    ($t:ident, $quat:ident, $vec3:ident, $mat3:ident, $mat4:ident, $inner:ident) => {
+    ($t:ident, $quat:ident, $vec3:ident, $vec4:ident, $mat3:ident, $mat4:ident, $inner:ident) => {
         /// The identity quaternion. Corresponds to no rotation.
         pub const IDENTITY: Self = Self($inner::W);
 
         /// Creates a new rotation quaternion.
         ///
+        /// This function does not check if the input is normalized, it is up to the user to
+        /// provide normalized input or to normalized the resulting quaternion.
+        ///
         /// This should generally not be called manually unless you know what you are doing.
         /// Use one of the other constructors instead such as `identity` or `from_axis_angle`.
         ///
@@ -48,6 +48,17 @@ macro_rules! impl_quat_methods {
             Self(Vector4::new(x, y, z, w))
         }
 
+        /// Creates a new rotation quaternion from a 4D vector.
+        ///
+        /// This function does not check if the input is normalized, it is up to the user to
+        /// provide normalized input or to normalized the resulting quaternion.
+        ///
+        /// The resulting quaternion is expected to be of unit length.
+        #[inline(always)]
+        pub fn from_vec4(v: $vec4) -> Self {
+            Self(v.0)
+        }
+
         /// Creates a rotation quaternion from an unaligned slice.
         ///
         /// # Preconditions
@@ -496,13 +507,6 @@ macro_rules! impl_quat_traits {
             }
         }
 
-        impl PartialOrd for $quat {
-            #[inline]
-            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-                self.as_ref().partial_cmp(other.as_ref())
-            }
-        }
-
         impl AsRef<[$t; 4]> for $quat {
             #[inline(always)]
             fn as_ref(&self) -> &[$t; 4] {
@@ -517,13 +521,6 @@ macro_rules! impl_quat_traits {
             }
         }
 
-        impl From<$vec4> for $quat {
-            #[inline(always)]
-            fn from(v: $vec4) -> Self {
-                Self(v.0)
-            }
-        }
-
         impl From<$quat> for $vec4 {
             #[inline(always)]
             fn from(q: $quat) -> Self {
@@ -531,13 +528,6 @@ macro_rules! impl_quat_traits {
             }
         }
 
-        impl From<($t, $t, $t, $t)> for $quat {
-            #[inline(always)]
-            fn from(t: ($t, $t, $t, $t)) -> Self {
-                Self(Vector4::from_tuple(t))
-            }
-        }
-
         impl From<$quat> for ($t, $t, $t, $t) {
             #[inline(always)]
             fn from(q: $quat) -> Self {
@@ -545,13 +535,6 @@ macro_rules! impl_quat_traits {
             }
         }
 
-        impl From<[$t; 4]> for $quat {
-            #[inline(always)]
-            fn from(a: [$t; 4]) -> Self {
-                Self(Vector4::from_array(a))
-            }
-        }
-
         impl From<$quat> for [$t; 4] {
             #[inline(always)]
             fn from(q: $quat) -> Self {
@@ -567,13 +550,6 @@ macro_rules! impl_quat_traits {
             }
         }
 
-        impl From<$inner> for $quat {
-            #[inline(always)]
-            fn from(inner: $inner) -> Self {
-                Self(inner)
-            }
-        }
-
         impl Deref for $quat {
             type Target = crate::XYZW<$t>;
             #[inline(always)]
@@ -623,11 +599,12 @@ type InnerF32 = crate::XYZW<f32>;
 pub struct Quat(pub(crate) InnerF32);
 
 impl Quat {
-    impl_quat_methods!(f32, Quat, Vec3, Mat3, Mat4, InnerF32);
+    impl_quat_methods!(f32, Quat, Vec3, Vec4, Mat3, Mat4, InnerF32);
 
     #[inline(always)]
     /// Multiplies a quaternion and a 3D vector, returning the rotated vector.
     pub fn mul_vec3a(self, other: Vec3A) -> Vec3A {
+        #[allow(clippy::useless_conversion)]
         Vec3A(self.0.mul_float4_as_vector3(other.0.into()).into())
     }
 
@@ -669,7 +646,7 @@ type InnerF64 = crate::XYZW<f64>;
 pub struct DQuat(pub(crate) InnerF64);
 
 impl DQuat {
-    impl_quat_methods!(f64, DQuat, DVec3, DMat3, DMat4, InnerF64);
+    impl_quat_methods!(f64, DQuat, DVec3, DVec4, DMat3, DMat4, InnerF64);
 
     #[inline(always)]
     pub fn as_f32(self) -> Quat {
diff --git a/src/transform.rs b/src/transform.rs
index d1f3f80..409db5b 100644
--- a/src/transform.rs
+++ b/src/transform.rs
@@ -1,3 +1,5 @@
+#![allow(deprecated)]
+
 use crate::{Affine3A, Mat4, Quat, Vec3, Vec3A, Vec3Swizzles};
 use core::ops::Mul;
 
@@ -14,13 +16,17 @@ use rand::{
  */
 #[derive(Clone, Copy, PartialEq, Debug)]
 #[repr(C)]
-pub struct Transform3A {
-    pub translation: Vec3A,
+#[deprecated(
+    since = "0.15.0",
+    note = "Moving to a separate crate, see https://github.com/bitshifter/glam-rs/issues/175"
+)]
+pub struct TransformSRT {
     pub rotation: Quat,
-    pub scale: Vec3A,
+    pub translation: Vec3,
+    pub scale: Vec3,
 }
 
-impl Default for Transform3A {
+impl Default for TransformSRT {
     #[inline]
     fn default() -> Self {
         Self::IDENTITY
@@ -34,39 +40,43 @@ impl Default for Transform3A {
  */
 #[derive(Clone, Copy, PartialEq, Debug)]
 #[repr(C)]
-pub struct Isometry3A {
-    pub translation: Vec3A,
+#[deprecated(
+    since = "0.15.0",
+    note = "Moving to a separate crate, see https://github.com/bitshifter/glam-rs/issues/175"
+)]
+pub struct TransformRT {
     pub rotation: Quat,
+    pub translation: Vec3,
 }
 
-impl Default for Isometry3A {
+impl Default for TransformRT {
     #[inline]
     fn default() -> Self {
         Self::IDENTITY
     }
 }
 
-impl Transform3A {
+impl TransformSRT {
     /// The identity transforms that does nothing.
     pub const IDENTITY: Self = Self {
-        scale: Vec3A::ONE,
+        scale: Vec3::ONE,
         rotation: Quat::IDENTITY,
-        translation: Vec3A::ZERO,
+        translation: Vec3::ZERO,
     };
 
     #[inline]
     pub fn from_scale_rotation_translation(scale: Vec3, rotation: Quat, translation: Vec3) -> Self {
         Self {
-            scale: scale.into(),
             rotation,
-            translation: translation.into(),
+            translation,
+            scale,
         }
     }
 
     #[inline]
-    pub fn from_scale_isometry(scale: Vec3, rt: &Isometry3A) -> Self {
+    pub fn from_scale_isometry(scale: Vec3, rt: &TransformRT) -> Self {
         Self {
-            scale: scale.into(),
+            scale,
             rotation: rt.rotation,
             translation: rt.translation,
         }
@@ -78,9 +88,9 @@ impl Transform3A {
         let rotation = self.rotation.conjugate();
         let translation = -(rotation * (self.translation * scale));
         Self {
-            scale,
             rotation,
             translation,
+            scale,
         }
     }
 
@@ -120,12 +130,12 @@ impl Transform3A {
 
     #[inline]
     pub fn transform_point3a(&self, other: Vec3A) -> Vec3A {
-        (self.rotation * (other * self.scale)) + self.translation
+        (self.rotation * (other * Vec3A::from(self.scale))) + Vec3A::from(self.translation)
     }
 
     #[inline]
     pub fn transform_vector3a(&self, other: Vec3A) -> Vec3A {
-        self.rotation * (other * self.scale)
+        self.rotation * (other * Vec3A::from(self.scale))
     }
 
     /// Returns true if the absolute difference of all elements between `self`
@@ -148,23 +158,19 @@ impl Transform3A {
 }
 
 #[inline]
-fn mul_srt_srt(lhs: &Transform3A, rhs: &Transform3A) -> Transform3A {
+fn mul_srt_srt(lhs: &TransformSRT, rhs: &TransformSRT) -> TransformSRT {
     // Based on https://github.com/nfrechette/rtm `rtm::qvv_mul`
-    let min_scale = lhs.scale.min(rhs.scale);
-    let scale = lhs.scale * rhs.scale;
+    let lhs_scale = Vec3A::from(lhs.scale);
+    let rhs_scale = Vec3A::from(rhs.scale);
+    let min_scale = lhs_scale.min(rhs_scale);
+    let scale = lhs_scale * rhs_scale;
 
     if min_scale.cmplt(Vec3A::ZERO).any() {
         // If negative scale, we go through a matrix
-        let lhs_mtx = Affine3A::from_scale_rotation_translation(
-            lhs.scale.into(),
-            lhs.rotation,
-            lhs.translation.into(),
-        );
-        let rhs_mtx = Affine3A::from_scale_rotation_translation(
-            rhs.scale.into(),
-            rhs.rotation,
-            rhs.translation.into(),
-        );
+        let lhs_mtx =
+            Affine3A::from_scale_rotation_translation(lhs.scale, lhs.rotation, lhs.translation);
+        let rhs_mtx =
+            Affine3A::from_scale_rotation_translation(rhs.scale, rhs.rotation, rhs.translation);
         let mut result_mtx = lhs_mtx * rhs_mtx;
 
         let sign = scale.signum();
@@ -172,47 +178,47 @@ fn mul_srt_srt(lhs: &Transform3A, rhs: &Transform3A) -> Transform3A {
         result_mtx.y_axis = result_mtx.y_axis.normalize() * sign.yyy();
         result_mtx.z_axis = result_mtx.z_axis.normalize() * sign.zzz();
 
-        let scale = scale;
+        let scale = Vec3::from(scale);
         let rotation = Quat::from_affine3(&result_mtx);
-        let translation = result_mtx.w_axis.xyz();
-        Transform3A {
-            scale,
+        let translation = Vec3::from(result_mtx.translation);
+        TransformSRT {
             rotation,
             translation,
+            scale,
         }
     } else {
         let rotation = lhs.rotation * rhs.rotation;
         let translation = (rhs.rotation * (lhs.translation * rhs.scale)) + rhs.translation;
-        Transform3A {
-            scale,
+        TransformSRT {
             rotation,
             translation,
+            scale: scale.into(),
         }
     }
 }
 
 #[inline]
-fn mul_rt_rt(lhs: &Isometry3A, rhs: &Isometry3A) -> Isometry3A {
+fn mul_rt_rt(lhs: &TransformRT, rhs: &TransformRT) -> TransformRT {
     let rotation = lhs.rotation * rhs.rotation;
     let translation = (rhs.rotation * lhs.translation) + rhs.translation;
-    Isometry3A {
+    TransformRT {
         rotation,
         translation,
     }
 }
 
-impl Isometry3A {
+impl TransformRT {
     /// The identity transforms that does nothing.
     pub const IDENTITY: Self = Self {
         rotation: Quat::IDENTITY,
-        translation: Vec3A::ZERO,
+        translation: Vec3::ZERO,
     };
 
     #[inline]
     pub fn from_rotation_translation(rotation: Quat, translation: Vec3) -> Self {
         Self {
             rotation,
-            translation: translation.into(),
+            translation,
         }
     }
 
@@ -273,7 +279,7 @@ impl Isometry3A {
 
     #[inline]
     pub fn transform_point3a(&self, other: Vec3A) -> Vec3A {
-        (self.rotation * other) + self.translation
+        (self.rotation * other) + Vec3A::from(self.translation)
     }
 
     #[inline]
@@ -299,15 +305,15 @@ impl Isometry3A {
     }
 }
 
-impl Mul<Isometry3A> for Isometry3A {
-    type Output = Isometry3A;
+impl Mul<TransformRT> for TransformRT {
+    type Output = TransformRT;
     #[inline]
-    fn mul(self, other: Isometry3A) -> Isometry3A {
+    fn mul(self, other: TransformRT) -> TransformRT {
         mul_rt_rt(&self, &other)
     }
 }
 
-impl Mul<Transform3A> for Transform3A {
+impl Mul<TransformSRT> for TransformSRT {
     type Output = Self;
     #[inline]
     fn mul(self, other: Self) -> Self::Output {
@@ -315,38 +321,38 @@ impl Mul<Transform3A> for Transform3A {
     }
 }
 
-impl Mul<Isometry3A> for Transform3A {
-    type Output = Transform3A;
+impl Mul<TransformRT> for TransformSRT {
+    type Output = TransformSRT;
     #[inline]
-    fn mul(self, other: Isometry3A) -> Self::Output {
+    fn mul(self, other: TransformRT) -> Self::Output {
         mul_srt_srt(&self, &other.into())
     }
 }
 
-impl Mul<Transform3A> for Isometry3A {
-    type Output = Transform3A;
+impl Mul<TransformSRT> for TransformRT {
+    type Output = TransformSRT;
     #[inline]
-    fn mul(self, other: Transform3A) -> Self::Output {
+    fn mul(self, other: TransformSRT) -> Self::Output {
         mul_srt_srt(&self.into(), &other)
     }
 }
 
-impl From<Isometry3A> for Transform3A {
+impl From<TransformRT> for TransformSRT {
     #[inline]
-    fn from(tr: Isometry3A) -> Self {
+    fn from(tr: TransformRT) -> Self {
         Self {
             translation: tr.translation,
             rotation: tr.rotation,
-            scale: Vec3A::ONE,
+            scale: Vec3::ONE,
         }
     }
 }
 
 #[cfg(feature = "rand")]
-impl Distribution<Isometry3A> for Standard {
+impl Distribution<TransformRT> for Standard {
     #[inline]
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Isometry3A {
-        Isometry3A::from_rotation_translation(
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> TransformRT {
+        TransformRT::from_rotation_translation(
             rng.gen::<Quat>(),
             Vec3::new(
                 rng.gen_range(core::f32::MIN..=core::f32::MAX),
@@ -358,16 +364,16 @@ impl Distribution<Isometry3A> for Standard {
 }
 
 #[cfg(feature = "rand")]
-impl Distribution<Transform3A> for Standard {
+impl Distribution<TransformSRT> for Standard {
     #[inline]
-    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Transform3A {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> TransformSRT {
         let mut gen_non_zero = || loop {
             let f: f32 = rng.gen_range(core::f32::MIN..=core::f32::MAX);
             if f.abs() > core::f32::MIN_POSITIVE {
                 return f;
             }
         };
-        Transform3A::from_scale_rotation_translation(
+        TransformSRT::from_scale_rotation_translation(
             Vec3::new(gen_non_zero(), gen_non_zero(), gen_non_zero()),
             rng.gen::<Quat>(),
             Vec3::new(
@@ -379,38 +385,30 @@ impl Distribution<Transform3A> for Standard {
     }
 }
 
-impl From<Transform3A> for Mat4 {
+impl From<TransformSRT> for Mat4 {
     #[inline]
-    fn from(srt: Transform3A) -> Self {
-        Self::from_scale_rotation_translation(
-            srt.scale.into(),
-            srt.rotation,
-            srt.translation.into(),
-        )
+    fn from(srt: TransformSRT) -> Self {
+        Self::from_scale_rotation_translation(srt.scale, srt.rotation, srt.translation)
     }
 }
 
-impl From<Isometry3A> for Mat4 {
+impl From<TransformRT> for Mat4 {
     #[inline]
-    fn from(rt: Isometry3A) -> Self {
-        Self::from_rotation_translation(rt.rotation, rt.translation.into())
+    fn from(rt: TransformRT) -> Self {
+        Self::from_rotation_translation(rt.rotation, rt.translation)
     }
 }
 
-impl From<Transform3A> for Affine3A {
+impl From<TransformSRT> for Affine3A {
     #[inline]
-    fn from(srt: Transform3A) -> Self {
-        Self::from_scale_rotation_translation(
-            srt.scale.into(),
-            srt.rotation,
-            srt.translation.into(),
-        )
+    fn from(srt: TransformSRT) -> Self {
+        Self::from_scale_rotation_translation(srt.scale, srt.rotation, srt.translation)
     }
 }
 
-impl From<Isometry3A> for Affine3A {
+impl From<TransformRT> for Affine3A {
     #[inline]
-    fn from(rt: Isometry3A) -> Self {
-        Self::from_rotation_translation(rt.rotation, rt.translation.into())
+    fn from(rt: TransformRT) -> Self {
+        Self::from_rotation_translation(rt.rotation, rt.translation)
     }
 }
diff --git a/src/vec.rs b/src/vec.rs
index d9ba7b8..44ded84 100644
--- a/src/vec.rs
+++ b/src/vec.rs
@@ -410,13 +410,6 @@ macro_rules! impl_vecn_common_traits {
             }
         }
 
-        impl PartialOrd for $vecn {
-            #[inline]
-            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-                self.as_ref().partial_cmp(other.as_ref())
-            }
-        }
-
         impl From<$vecn> for $inner {
             #[inline(always)]
             fn from(t: $vecn) -> Self {
diff --git a/src/vec2.rs b/src/vec2.rs
index 1f19fd8..c7d9641 100644
--- a/src/vec2.rs
+++ b/src/vec2.rs
@@ -2,7 +2,7 @@ use crate::core::traits::vector::*;
 use crate::{BVec2, DVec3, IVec3, UVec3, Vec3, XY};
 #[cfg(not(target_arch = "spirv"))]
 use core::fmt;
-use core::{cmp::Ordering, f32, ops::*};
+use core::{f32, ops::*};
 
 #[cfg(not(feature = "std"))]
 use num_traits::Float;
diff --git a/src/vec3.rs b/src/vec3.rs
index 6b492cf..e6888ea 100644
--- a/src/vec3.rs
+++ b/src/vec3.rs
@@ -4,7 +4,7 @@ use crate::BVec3A;
 use crate::{BVec3, DVec2, DVec4, IVec2, IVec4, UVec2, UVec4, Vec2, Vec4, XYZ};
 #[cfg(not(target_arch = "spirv"))]
 use core::fmt;
-use core::{cmp::Ordering, f32, ops::*};
+use core::{f32, ops::*};
 
 #[cfg(not(feature = "std"))]
 use num_traits::Float;
diff --git a/src/vec4.rs b/src/vec4.rs
index 2e6f88c..19ca531 100644
--- a/src/vec4.rs
+++ b/src/vec4.rs
@@ -26,7 +26,7 @@ use core::arch::x86_64::*;
 #[cfg(feature = "std")]
 use std::iter::{Product, Sum};
 
-use core::{cmp::Ordering, f32};
+use core::f32;
 
 macro_rules! impl_vec4_common_methods {
     ($t:ty, $vec2:ident, $vec3:ident, $vec4:ident, $mask:ident, $inner:ident) => {
@@ -236,6 +236,7 @@ impl From<Vec4> for Vec3A {
     /// On architectures where SIMD is supported such as SSE2 on x86_64 this conversion is a noop.
     #[inline(always)]
     fn from(v: Vec4) -> Self {
+        #[allow(clippy::useless_conversion)]
         Self(v.0.into())
     }
 }
diff --git a/src/vec_mask.rs b/src/vec_mask.rs
index a050f67..fd46033 100644
--- a/src/vec_mask.rs
+++ b/src/vec_mask.rs
@@ -3,7 +3,7 @@ use crate::core::traits::vector::{
 };
 #[cfg(not(target_arch = "spirv"))]
 use core::fmt;
-use core::{cmp::Ordering, hash, ops::*};
+use core::{hash, ops::*};
 
 #[cfg(all(
     target_arch = "x86",
@@ -63,20 +63,6 @@ macro_rules! impl_vecnmask_traits {
 
         impl Eq for $vecnmask {}
 
-        impl Ord for $vecnmask {
-            #[inline]
-            fn cmp(&self, other: &Self) -> Ordering {
-                self.as_ref().cmp(other.as_ref())
-            }
-        }
-
-        impl PartialOrd for $vecnmask {
-            #[inline]
-            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-                Some(self.cmp(other))
-            }
-        }
-
         impl hash::Hash for $vecnmask {
             #[inline]
             fn hash<H: hash::Hasher>(&self, state: &mut H) {


Test patch:
diff --git a/tests/affine2.rs b/tests/affine2.rs
index e074e5a..1c6cccd 100644
--- a/tests/affine2.rs
+++ b/tests/affine2.rs
@@ -1,8 +1,6 @@
-#[cfg(feature = "transform-types")]
 #[macro_use]
 mod support;
 
-#[cfg(feature = "transform-types")]
 macro_rules! impl_affine2_tests {
     ($t:ident, $affine2:ident, $vec2:ident) => {
         use core::$t::NAN;
@@ -114,11 +112,24 @@ macro_rules! impl_affine2_tests {
     };
 }
 
-#[cfg(feature = "transform-types")]
 mod affine2 {
-    use super::support::deg;
+    use super::support::{deg, FloatCompare};
     use glam::{Affine2, Vec2};
 
+    impl FloatCompare for Affine2 {
+        #[inline]
+        fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+            self.abs_diff_eq(*other, max_abs_diff)
+        }
+        #[inline]
+        fn abs_diff(&self, other: &Self) -> Self {
+            Self {
+                matrix2: self.matrix2.abs_diff(&other.matrix2),
+                translation: self.translation.abs_diff(&other.translation),
+            }
+        }
+    }
+
     #[test]
     fn test_align() {
         use std::mem;
@@ -135,11 +146,24 @@ mod affine2 {
     impl_affine2_tests!(f32, Affine2, Vec2);
 }
 
-#[cfg(feature = "transform-types")]
 mod daffine2 {
-    use super::support::deg;
+    use super::support::{deg, FloatCompare};
     use glam::{DAffine2, DVec2};
 
+    impl FloatCompare for DAffine2 {
+        #[inline]
+        fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+            self.abs_diff_eq(*other, max_abs_diff as f64)
+        }
+        #[inline]
+        fn abs_diff(&self, other: &Self) -> Self {
+            Self {
+                matrix2: self.matrix2.abs_diff(&other.matrix2),
+                translation: self.translation.abs_diff(&other.translation),
+            }
+        }
+    }
+
     #[test]
     fn test_align() {
         use std::mem;
diff --git a/tests/affine3.rs b/tests/affine3.rs
index f51da4a..7053b6d 100644
--- a/tests/affine3.rs
+++ b/tests/affine3.rs
@@ -1,8 +1,6 @@
-#[cfg(feature = "transform-types")]
 #[macro_use]
 mod support;
 
-#[cfg(feature = "transform-types")]
 macro_rules! impl_affine3_tests {
     ($t:ident, $affine3:ident, $quat:ident, $vec3:ident) => {
         use core::$t::NAN;
@@ -217,11 +215,24 @@ macro_rules! impl_affine3_tests {
     };
 }
 
-#[cfg(feature = "transform-types")]
 mod affine3a {
-    use super::support::deg;
+    use super::support::{deg, FloatCompare};
     use glam::{Affine3A, Quat, Vec3, Vec3A};
 
+    impl FloatCompare for Affine3A {
+        #[inline]
+        fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+            self.abs_diff_eq(*other, max_abs_diff)
+        }
+        #[inline]
+        fn abs_diff(&self, other: &Self) -> Self {
+            Self {
+                matrix3: self.matrix3.abs_diff(&other.matrix3),
+                translation: self.translation.abs_diff(&other.translation),
+            }
+        }
+    }
+
     #[test]
     fn test_align() {
         use std::mem;
@@ -250,11 +261,24 @@ mod affine3a {
     impl_affine3_tests!(f32, Affine3A, Quat, Vec3);
 }
 
-#[cfg(feature = "transform-types")]
 mod daffine3 {
-    use super::support::deg;
+    use super::support::{deg, FloatCompare};
     use glam::{DAffine3, DQuat, DVec3};
 
+    impl FloatCompare for DAffine3 {
+        #[inline]
+        fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+            self.abs_diff_eq(*other, max_abs_diff as f64)
+        }
+        #[inline]
+        fn abs_diff(&self, other: &Self) -> Self {
+            Self {
+                matrix3: self.matrix3.abs_diff(&other.matrix3),
+                translation: self.translation.abs_diff(&other.translation),
+            }
+        }
+    }
+
     #[test]
     fn test_align() {
         use std::mem;
diff --git a/tests/quat.rs b/tests/quat.rs
index 77bf7b9..4c39f0a 100644
--- a/tests/quat.rs
+++ b/tests/quat.rs
@@ -18,18 +18,15 @@ macro_rules! impl_quat_tests {
             let ytheta = deg(45.0);
             let q0 = $quat::from_rotation_y(ytheta);
 
-            let t1 = (0.0, (ytheta * 0.5).sin(), 0.0, (ytheta * 0.5).cos());
-            assert_eq!(q0, t1.into());
-            let q1 = $quat::from(t1);
-            assert_eq!(t1, q1.into());
-
-            assert_eq!(q0, $new(t1.0, t1.1, t1.2, t1.3));
-
-            let a1 = [0.0, (ytheta * 0.5).sin(), 0.0, (ytheta * 0.5).cos()];
-            assert_eq!(q0, a1.into());
-            let q1 = $quat::from(a1);
-            let a2: [$t; 4] = q1.into();
-            assert_eq!(a1, a2);
+            let v1 = $vec4::new(0.0, (ytheta * 0.5).sin(), 0.0, (ytheta * 0.5).cos());
+            assert_eq!(q0, $quat::from_vec4(v1));
+            let q1 = $quat::from_vec4(v1);
+            assert_eq!(v1, q1.into());
+
+            assert_eq!(q0, $new(v1.x, v1.y, v1.z, v1.w));
+
+            let a1: [$t; 4] = q1.into();
+            assert_eq!([v1.x, v1.y, v1.z, v1.w], a1);
         }
 
         #[test]
@@ -44,7 +41,7 @@ macro_rules! impl_quat_tests {
             assert_approx_eq!(q0.dot(q0), 1.0);
             assert_approx_eq!(q0.dot(q0), 1.0);
 
-            let q1 = $quat::from($vec4::from(q0) * 2.0);
+            let q1 = $quat::from_vec4($vec4::from(q0) * 2.0);
             assert!(!q1.is_normalized());
             assert_approx_eq!(q1.length_squared(), 4.0, 1.0e-6);
             assert_approx_eq!(q1.length(), 2.0);
diff --git a/tests/support/mod.rs b/tests/support/mod.rs
index 3e3ba4a..a22f371 100644
--- a/tests/support/mod.rs
+++ b/tests/support/mod.rs
@@ -6,9 +6,6 @@ use glam::{
     Vec3A, Vec4,
 };
 
-#[cfg(feature = "transform-types")]
-use glam::{Affine2, Affine3A, DAffine2, DAffine3, Isometry3A, Transform3A};
-
 pub trait Deg {
     fn to_radians(self) -> Self;
 }
@@ -160,66 +157,6 @@ impl FloatCompare for DMat4 {
     }
 }
 
-#[cfg(feature = "transform-types")]
-impl FloatCompare for Affine2 {
-    #[inline]
-    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
-        self.abs_diff_eq(*other, max_abs_diff)
-    }
-    #[inline]
-    fn abs_diff(&self, other: &Self) -> Self {
-        Self {
-            matrix2: self.matrix2.abs_diff(&other.matrix2),
-            translation: self.translation.abs_diff(&other.translation),
-        }
-    }
-}
-
-#[cfg(feature = "transform-types")]
-impl FloatCompare for DAffine2 {
-    #[inline]
-    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
-        self.abs_diff_eq(*other, max_abs_diff as f64)
-    }
-    #[inline]
-    fn abs_diff(&self, other: &Self) -> Self {
-        Self {
-            matrix2: self.matrix2.abs_diff(&other.matrix2),
-            translation: self.translation.abs_diff(&other.translation),
-        }
-    }
-}
-
-#[cfg(feature = "transform-types")]
-impl FloatCompare for Affine3A {
-    #[inline]
-    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
-        self.abs_diff_eq(*other, max_abs_diff)
-    }
-    #[inline]
-    fn abs_diff(&self, other: &Self) -> Self {
-        Self {
-            matrix3: self.matrix3.abs_diff(&other.matrix3),
-            translation: self.translation.abs_diff(&other.translation),
-        }
-    }
-}
-
-#[cfg(feature = "transform-types")]
-impl FloatCompare for DAffine3 {
-    #[inline]
-    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
-        self.abs_diff_eq(*other, max_abs_diff as f64)
-    }
-    #[inline]
-    fn abs_diff(&self, other: &Self) -> Self {
-        Self {
-            matrix3: self.matrix3.abs_diff(&other.matrix3),
-            translation: self.translation.abs_diff(&other.translation),
-        }
-    }
-}
-
 impl FloatCompare for Mat4 {
     #[inline]
     fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
@@ -245,7 +182,7 @@ impl FloatCompare for Quat {
     fn abs_diff(&self, other: &Self) -> Self {
         let a: Vec4 = (*self).into();
         let b: Vec4 = (*other).into();
-        (a - b).abs().into()
+        Quat::from_vec4((a - b).abs())
     }
 }
 
@@ -302,7 +239,7 @@ impl FloatCompare for DQuat {
     fn abs_diff(&self, other: &Self) -> Self {
         let a: DVec4 = (*self).into();
         let b: DVec4 = (*other).into();
-        (a - b).abs().into()
+        DQuat::from_vec4((a - b).abs())
     }
 }
 
@@ -338,36 +275,3 @@ impl FloatCompare for DVec4 {
         (*self - *other).abs()
     }
 }
-
-#[cfg(feature = "transform-types")]
-impl FloatCompare for Transform3A {
-    #[inline]
-    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
-        self.abs_diff_eq(*other, max_abs_diff)
-    }
-
-    #[inline]
-    fn abs_diff(&self, other: &Self) -> Self {
-        Self::from_scale_rotation_translation(
-            self.scale.abs_diff(&other.scale).into(),
-            self.rotation.abs_diff(&other.rotation),
-            self.translation.abs_diff(&other.translation).into(),
-        )
-    }
-}
-
-#[cfg(feature = "transform-types")]
-impl FloatCompare for Isometry3A {
-    #[inline]
-    fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
-        self.abs_diff_eq(*other, max_abs_diff)
-    }
-
-    #[inline]
-    fn abs_diff(&self, other: &Self) -> Self {
-        Self::from_rotation_translation(
-            self.rotation.abs_diff(&other.rotation),
-            self.translation.abs_diff(&other.translation).into(),
-        )
-    }
-}
diff --git a/tests/transform.rs b/tests/transform.rs
index 255490b..014fea2 100644
--- a/tests/transform.rs
+++ b/tests/transform.rs
@@ -1,26 +1,60 @@
+#![allow(deprecated)]
+
 #[cfg(feature = "transform-types")]
 #[macro_use]
 mod support;
 
 #[cfg(feature = "transform-types")]
 mod transform {
+    use crate::support::FloatCompare;
     use glam::*;
 
+    impl FloatCompare for TransformSRT {
+        #[inline]
+        fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+            self.abs_diff_eq(*other, max_abs_diff)
+        }
+
+        #[inline]
+        fn abs_diff(&self, other: &Self) -> Self {
+            Self::from_scale_rotation_translation(
+                self.scale.abs_diff(&other.scale).into(),
+                self.rotation.abs_diff(&other.rotation),
+                self.translation.abs_diff(&other.translation).into(),
+            )
+        }
+    }
+
+    impl FloatCompare for TransformRT {
+        #[inline]
+        fn approx_eq(&self, other: &Self, max_abs_diff: f32) -> bool {
+            self.abs_diff_eq(*other, max_abs_diff)
+        }
+
+        #[inline]
+        fn abs_diff(&self, other: &Self) -> Self {
+            Self::from_rotation_translation(
+                self.rotation.abs_diff(&other.rotation),
+                self.translation.abs_diff(&other.translation).into(),
+            )
+        }
+    }
+
     #[test]
     fn test_identity() {
-        let tr = Isometry3A::IDENTITY;
+        let tr = TransformRT::IDENTITY;
         assert_eq!(tr.rotation, Quat::IDENTITY);
-        assert_eq!(tr.translation, Vec3A::ZERO);
+        assert_eq!(tr.translation, Vec3::ZERO);
 
-        let srt = Transform3A::IDENTITY;
-        assert_eq!(srt.scale, Vec3A::ONE);
+        let srt = TransformSRT::IDENTITY;
+        assert_eq!(srt.scale, Vec3::ONE);
         assert_eq!(srt.rotation, Quat::IDENTITY);
-        assert_eq!(srt.translation, Vec3A::ZERO);
+        assert_eq!(srt.translation, Vec3::ZERO);
 
         assert_eq!(srt, tr.into());
 
-        assert_eq!(Isometry3A::IDENTITY, Isometry3A::default());
-        assert_eq!(Transform3A::IDENTITY, Transform3A::default());
+        assert_eq!(TransformRT::IDENTITY, TransformRT::default());
+        assert_eq!(TransformSRT::IDENTITY, TransformSRT::default());
     }
 
     #[test]
@@ -29,23 +63,23 @@ mod transform {
         let r = Quat::from_rotation_y(90.0_f32.to_radians());
         let s = Vec3::new(-1.0, -2.0, -3.0);
 
-        let tr = Isometry3A::from_rotation_translation(r, t);
+        let tr = TransformRT::from_rotation_translation(r, t);
         assert_eq!(tr.rotation, r);
         assert_eq!(tr.translation, t.into());
 
-        let srt = Transform3A::from_scale_rotation_translation(s, r, t);
+        let srt = TransformSRT::from_scale_rotation_translation(s, r, t);
         assert_eq!(srt.scale, s.into());
         assert_eq!(srt.rotation, r);
         assert_eq!(srt.translation, t.into());
 
         assert_eq!(tr, tr);
         assert_eq!(srt, srt);
-        assert_eq!(srt, Transform3A::from_scale_isometry(s, &tr));
+        assert_eq!(srt, TransformSRT::from_scale_isometry(s, &tr));
     }
 
     #[test]
     fn test_mul() {
-        let tr = Isometry3A::from_rotation_translation(
+        let tr = TransformRT::from_rotation_translation(
             Quat::from_rotation_z(-90.0_f32.to_radians()),
             Vec3::X,
         );
@@ -57,16 +91,16 @@ mod transform {
         let v2 = inv_tr.transform_point3a(v1);
         assert_approx_eq!(v0, v2);
 
-        assert_eq!(tr * Isometry3A::IDENTITY, tr);
-        assert_approx_eq!(tr * inv_tr, Isometry3A::IDENTITY);
+        assert_eq!(tr * TransformRT::IDENTITY, tr);
+        assert_approx_eq!(tr * inv_tr, TransformRT::IDENTITY);
 
-        assert_eq!(tr * Transform3A::IDENTITY, Transform3A::from(tr));
-        assert_eq!(Transform3A::IDENTITY * tr, Transform3A::from(tr));
+        assert_eq!(tr * TransformSRT::IDENTITY, TransformSRT::from(tr));
+        assert_eq!(TransformSRT::IDENTITY * tr, TransformSRT::from(tr));
 
         let s = Vec3::splat(2.0);
         let r = Quat::from_rotation_y(180.0_f32.to_radians());
         let t = -Vec3::Y;
-        let srt = Transform3A::from_scale_rotation_translation(s, r, t);
+        let srt = TransformSRT::from_scale_rotation_translation(s, r, t);
         let v0 = Vec3A::X;
         let v1 = srt.transform_point3a(v0);
         assert_approx_eq!(v1, (r * (v0 * Vec3A::from(s))) + Vec3A::from(t));
@@ -75,13 +109,13 @@ mod transform {
         let v2 = inv_srt.transform_point3a(v1);
         assert_approx_eq!(v0, v2);
 
-        assert_eq!(srt * Transform3A::IDENTITY, srt);
-        assert_eq!(srt * inv_srt, Transform3A::IDENTITY);
+        assert_eq!(srt * TransformSRT::IDENTITY, srt);
+        assert_eq!(srt * inv_srt, TransformSRT::IDENTITY);
 
         // negative scale mul test
         let s = Vec3::splat(-2.0);
-        let srt = Transform3A::from_scale_rotation_translation(s, r, t);
+        let srt = TransformSRT::from_scale_rotation_translation(s, r, t);
         let inv_srt = srt.inverse();
-        assert_eq!(srt * inv_srt, Transform3A::IDENTITY);
+        assert_eq!(srt * inv_srt, TransformSRT::IDENTITY);
     }
 }
diff --git a/tests/vec2.rs b/tests/vec2.rs
index 5612d02..504a2e3 100644
--- a/tests/vec2.rs
+++ b/tests/vec2.rs
@@ -179,8 +179,6 @@ macro_rules! impl_vec2_tests {
             assert!(c.cmple(c).all());
             assert!(c.cmpge(c).all());
             assert!(a == a);
-            assert!(a < b);
-            assert!(b > a);
         }
 
         #[test]
@@ -340,9 +338,6 @@ macro_rules! impl_vec2_tests {
             assert_eq!(b, a);
             assert_ne!(a, c);
             assert_ne!(b, c);
-
-            assert!(a > c);
-            assert!(c < a);
         }
 
         #[test]
diff --git a/tests/vec3.rs b/tests/vec3.rs
index 2df1e8d..5880150 100644
--- a/tests/vec3.rs
+++ b/tests/vec3.rs
@@ -195,8 +195,6 @@ macro_rules! impl_vec3_tests {
             assert!(c.cmple(c).all());
             assert!(c.cmpge(c).all());
             assert!(a == a);
-            assert!(a < b);
-            assert!(b > a);
         }
 
         #[test]
@@ -384,9 +382,6 @@ macro_rules! impl_vec3_tests {
             assert_eq!(b, a);
             assert_ne!(a, c);
             assert_ne!(b, c);
-
-            assert!(a > c);
-            assert!(c < a);
         }
 
         #[test]
diff --git a/tests/vec4.rs b/tests/vec4.rs
index 985b5b7..c5b29a7 100644
--- a/tests/vec4.rs
+++ b/tests/vec4.rs
@@ -248,8 +248,6 @@ macro_rules! impl_vec4_tests {
             assert!(a.cmpne(b).all());
             assert!(a.cmpne(c).any());
             assert!(a == a);
-            assert!(a < b);
-            assert!(b > a);
         }
 
         #[test]
@@ -452,9 +450,6 @@ macro_rules! impl_vec4_tests {
             assert_eq!(b, a);
             assert_ne!(a, c);
             assert_ne!(b, c);
-
-            assert!(a > c);
-            assert!(c < a);
         }
 
         #[test]