feat: add From trait implementations between f32 and f64 variants of each structs + release v0.1.3

CHANGELOG.md

@@ -1,3 +1,7 @@
+# v0.1.3
+
+- Add `From`/`Into` conversions between f32 and f64 type variants.
+
 # v0.1.2
 
 - Add optional `rkyv 0.8` support.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "glamx"
-version = "0.1.2"
+version = "0.1.3"
 authors = ["Sébastien Crozet <developer@crozet.re>"]
 
 description = "Extensions for glam: Pose2, Pose3, Rot2, and matrix utilities."

src/eigen2.rs

@@ -77,6 +77,27 @@ macro_rules! impl_symmetric_eigen2 {
 impl_symmetric_eigen2!(SymmetricEigen2, glam::Mat2, glam::Vec2, f32);
 impl_symmetric_eigen2!(DSymmetricEigen2, glam::DMat2, glam::DVec2, f64);
 
+// f32 <-> f64 conversions
+impl From<SymmetricEigen2> for DSymmetricEigen2 {
+    #[inline]
+    fn from(e: SymmetricEigen2) -> Self {
+        Self {
+            eigenvalues: e.eigenvalues.as_dvec2(),
+            eigenvectors: e.eigenvectors.as_dmat2(),
+        }
+    }
+}
+
+impl From<DSymmetricEigen2> for SymmetricEigen2 {
+    #[inline]
+    fn from(e: DSymmetricEigen2) -> Self {
+        Self {
+            eigenvalues: e.eigenvalues.as_vec2(),
+            eigenvectors: e.eigenvectors.as_mat2(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/eigen3.rs

@@ -230,6 +230,68 @@ impl_symmetric_eigen3!(SymmetricEigen3, glam::Mat3, glam::Vec3, f32);
 impl_symmetric_eigen3!(SymmetricEigen3A, glam::Mat3A, glam::Vec3A, f32);
 impl_symmetric_eigen3!(DSymmetricEigen3, glam::DMat3, glam::DVec3, f64);
 
+// f32 <-> f64 conversions
+impl From<SymmetricEigen3> for DSymmetricEigen3 {
+    #[inline]
+    fn from(e: SymmetricEigen3) -> Self {
+        Self {
+            eigenvalues: e.eigenvalues.as_dvec3(),
+            eigenvectors: e.eigenvectors.as_dmat3(),
+        }
+    }
+}
+
+impl From<DSymmetricEigen3> for SymmetricEigen3 {
+    #[inline]
+    fn from(e: DSymmetricEigen3) -> Self {
+        Self {
+            eigenvalues: e.eigenvalues.as_vec3(),
+            eigenvectors: e.eigenvectors.as_mat3(),
+        }
+    }
+}
+
+impl From<SymmetricEigen3A> for DSymmetricEigen3 {
+    #[inline]
+    fn from(e: SymmetricEigen3A) -> Self {
+        Self {
+            eigenvalues: e.eigenvalues.as_dvec3(),
+            eigenvectors: e.eigenvectors.as_dmat3(),
+        }
+    }
+}
+
+impl From<DSymmetricEigen3> for SymmetricEigen3A {
+    #[inline]
+    fn from(e: DSymmetricEigen3) -> Self {
+        Self {
+            eigenvalues: e.eigenvalues.as_vec3a(),
+            eigenvectors: e.eigenvectors.as_mat3().into(),
+        }
+    }
+}
+
+// SymmetricEigen3 <-> SymmetricEigen3A conversions
+impl From<SymmetricEigen3> for SymmetricEigen3A {
+    #[inline]
+    fn from(e: SymmetricEigen3) -> Self {
+        Self {
+            eigenvalues: e.eigenvalues.into(),
+            eigenvectors: glam::Mat3A::from(e.eigenvectors),
+        }
+    }
+}
+
+impl From<SymmetricEigen3A> for SymmetricEigen3 {
+    #[inline]
+    fn from(e: SymmetricEigen3A) -> Self {
+        Self {
+            eigenvalues: e.eigenvalues.into(),
+            eigenvectors: glam::Mat3::from(e.eigenvectors),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/pose2.rs

@@ -364,6 +364,27 @@ impl_pose2!(
     glam::DMat3
 );
 
+// f32 <-> f64 conversions
+impl From<Pose2> for DPose2 {
+    #[inline]
+    fn from(p: Pose2) -> Self {
+        Self {
+            rotation: p.rotation.into(),
+            translation: p.translation.into(),
+        }
+    }
+}
+
+impl From<DPose2> for Pose2 {
+    #[inline]
+    fn from(p: DPose2) -> Self {
+        Self {
+            rotation: p.rotation.into(),
+            translation: p.translation.as_vec2(),
+        }
+    }
+}
+
 // Nalgebra conversions
 #[cfg(feature = "nalgebra")]
 mod nalgebra_conv {

src/pose3.rs

@@ -391,6 +391,68 @@ impl_pose3!(Pose3, Rot3, f32, glam::Vec3, glam::Mat4);
 impl_pose3!(Pose3A, Rot3, f32, glam::Vec3A, glam::Mat4);
 impl_pose3!(DPose3, DRot3, f64, glam::DVec3, glam::DMat4);
 
+// f32 <-> f64 conversions
+impl From<Pose3> for DPose3 {
+    #[inline]
+    fn from(p: Pose3) -> Self {
+        Self {
+            rotation: p.rotation.as_dquat(),
+            translation: p.translation.as_dvec3(),
+        }
+    }
+}
+
+impl From<DPose3> for Pose3 {
+    #[inline]
+    fn from(p: DPose3) -> Self {
+        Self {
+            rotation: p.rotation.as_quat(),
+            translation: p.translation.as_vec3(),
+        }
+    }
+}
+
+impl From<Pose3A> for DPose3 {
+    #[inline]
+    fn from(p: Pose3A) -> Self {
+        Self {
+            rotation: p.rotation.as_dquat(),
+            translation: p.translation.as_dvec3(),
+        }
+    }
+}
+
+impl From<DPose3> for Pose3A {
+    #[inline]
+    fn from(p: DPose3) -> Self {
+        Self {
+            rotation: p.rotation.as_quat(),
+            translation: p.translation.as_vec3a(),
+        }
+    }
+}
+
+// Pose3 <-> Pose3A conversions
+impl From<Pose3> for Pose3A {
+    #[inline]
+    fn from(p: Pose3) -> Self {
+        Self {
+            rotation: p.rotation,
+            translation: p.translation.into(),
+        }
+    }
+}
+
+impl From<Pose3A> for Pose3 {
+    #[inline]
+    fn from(p: Pose3A) -> Self {
+        Self {
+            rotation: p.rotation,
+            translation: p.translation.into(),
+        }
+    }
+}
+
 // Nalgebra conversions
 #[cfg(feature = "nalgebra")]
 mod nalgebra_conv {
@@ -435,17 +497,8 @@ mod nalgebra_conv {
     impl From<nalgebra::Isometry3<f64>> for DPose3 {
         fn from(iso: nalgebra::Isometry3<f64>) -> Self {
             Self {
-                rotation: glam::DQuat::from_xyzw(
-                    iso.rotation.i,
-                    iso.rotation.j,
-                    iso.rotation.k,
-                    iso.rotation.w,
-                ),
-                translation: glam::DVec3::new(
-                    iso.translation.x,
-                    iso.translation.y,
-                    iso.translation.z,
-                ),
+                rotation: iso.rotation.into(),
+                translation: iso.translation.into(),
             }
         }
     }

src/rot2.rs

@@ -365,6 +365,27 @@ macro_rules! impl_rot2 {
 impl_rot2!(Rot2, f32, glam::Vec2, glam::Mat2);
 impl_rot2!(DRot2, f64, glam::DVec2, glam::DMat2);
 
+// f32 <-> f64 conversions
+impl From<Rot2> for DRot2 {
+    #[inline]
+    fn from(r: Rot2) -> Self {
+        Self {
+            re: r.re as f64,
+            im: r.im as f64,
+        }
+    }
+}
+
+impl From<DRot2> for Rot2 {
+    #[inline]
+    fn from(r: DRot2) -> Self {
+        Self {
+            re: r.re as f32,
+            im: r.im as f32,
+        }
+    }
+}
+
 // Nalgebra conversions
 #[cfg(feature = "nalgebra")]
 mod nalgebra_conv {

src/svd2.rs

@@ -90,6 +90,29 @@ macro_rules! impl_svd2 {
 impl_svd2!(Svd2, glam::Mat2, glam::Vec2, f32);
 impl_svd2!(DSvd2, glam::DMat2, glam::DVec2, f64);
 
+// f32 <-> f64 conversions
+impl From<Svd2> for DSvd2 {
+    #[inline]
+    fn from(svd: Svd2) -> Self {
+        Self {
+            u: svd.u.as_dmat2(),
+            s: svd.s.as_dvec2(),
+            vt: svd.vt.as_dmat2(),
+        }
+    }
+}
+
+impl From<DSvd2> for Svd2 {
+    #[inline]
+    fn from(svd: DSvd2) -> Self {
+        Self {
+            u: svd.u.as_mat2(),
+            s: svd.s.as_vec2(),
+            vt: svd.vt.as_mat2(),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/svd3.rs

@@ -132,6 +132,74 @@ impl_svd3!(Svd3, glam::Mat3, glam::Vec3, SymmetricEigen3, f32);
 impl_svd3!(Svd3A, glam::Mat3A, glam::Vec3A, SymmetricEigen3A, f32);
 impl_svd3!(DSvd3, glam::DMat3, glam::DVec3, DSymmetricEigen3, f64);
 
+// f32 <-> f64 conversions
+impl From<Svd3> for DSvd3 {
+    #[inline]
+    fn from(svd: Svd3) -> Self {
+        Self {
+            u: svd.u.as_dmat3(),
+            s: svd.s.as_dvec3(),
+            vt: svd.vt.as_dmat3(),
+        }
+    }
+}
+
+impl From<DSvd3> for Svd3 {
+    #[inline]
+    fn from(svd: DSvd3) -> Self {
+        Self {
+            u: svd.u.as_mat3(),
+            s: svd.s.as_vec3(),
+            vt: svd.vt.as_mat3(),
+        }
+    }
+}
+
+impl From<Svd3A> for DSvd3 {
+    #[inline]
+    fn from(svd: Svd3A) -> Self {
+        Self {
+            u: svd.u.as_dmat3(),
+            s: svd.s.as_dvec3(),
+            vt: svd.vt.as_dmat3(),
+        }
+    }
+}
+
+impl From<DSvd3> for Svd3A {
+    #[inline]
+    fn from(svd: DSvd3) -> Self {
+        Self {
+            u: svd.u.as_mat3().into(),
+            s: svd.s.as_vec3a(),
+            vt: svd.vt.as_mat3().into(),
+        }
+    }
+}
+
+// Svd3 <-> Svd3A conversions
+impl From<Svd3> for Svd3A {
+    #[inline]
+    fn from(svd: Svd3) -> Self {
+        Self {
+            u: glam::Mat3A::from(svd.u),
+            s: svd.s.into(),
+            vt: glam::Mat3A::from(svd.vt),
+        }
+    }
+}
+
+impl From<Svd3A> for Svd3 {
+    #[inline]
+    fn from(svd: Svd3A) -> Self {
+        Self {
+            u: glam::Mat3::from(svd.u),
+            s: svd.s.into(),
+            vt: glam::Mat3::from(svd.vt),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;