Merge pull request #891 from djkoloski/dev

Add partial `rkyv` support

Cargo.toml

@@ -48,6 +48,8 @@ convert-bytemuck = [ "bytemuck" ]
 serde-serialize-no-std = [ "serde", "num-complex/serde" ]
 serde-serialize        = [ "serde-serialize-no-std", "serde/std" ]
 abomonation-serialize  = [ "abomonation" ]
+rkyv-serialize-no-std  = [ "rkyv" ]
+rkyv-serialize         = [ "rkyv-serialize-no-std", "rkyv/std" ]
 
 # Randomness
 ## To use rand in a #[no-std] environment, enable the
@@ -74,6 +76,7 @@ rand_distr     = { version = "0.4", default-features = false, optional = true }
 matrixmultiply = { version = "0.3", optional = true }
 serde          = { version = "1.0", default-features = false, features = [ "derive" ], optional = true }
 abomonation    = { version = "0.7", optional = true }
+rkyv           = { version = "~0.6.4", default-features = false, features = ["const_generics"], optional = true }
 mint           = { version = "0.5", optional = true }
 glam           = { version = "0.13", optional = true }
 quickcheck     = { version = "1", optional = true }
@@ -81,7 +84,7 @@ pest           = { version = "2", optional = true }
 pest_derive    = { version = "2", optional = true }
 bytemuck       = { version = "1.5", optional = true }
 matrixcompare-core = { version = "0.1", optional = true }
-proptest = { version = "1", optional = true, default-features = false, features = ["std"] }
+proptest           = { version = "1", optional = true, default-features = false, features = ["std"] }
 
 [dev-dependencies]
 serde_json = "1.0"

src/base/array_storage.rs

@@ -299,3 +299,45 @@ where
         self.as_slice().iter().fold(0, |acc, e| acc + e.extent())
     }
 }
+
+#[cfg(feature = "rkyv-serialize-no-std")]
+mod rkyv_impl {
+    use super::ArrayStorage;
+    use rkyv::{offset_of, project_struct, Archive, Deserialize, Fallible, Serialize};
+
+    impl<T: Archive, const R: usize, const C: usize> Archive for ArrayStorage<T, R, C> {
+        type Archived = ArrayStorage<T::Archived, R, C>;
+        type Resolver = <[[T; R]; C] as Archive>::Resolver;
+
+        fn resolve(
+            &self,
+            pos: usize,
+            resolver: Self::Resolver,
+            out: &mut core::mem::MaybeUninit<Self::Archived>,
+        ) {
+            self.0.resolve(
+                pos + offset_of!(Self::Archived, 0),
+                resolver,
+                project_struct!(out: Self::Archived => 0),
+            );
+        }
+    }
+
+    impl<T: Serialize<S>, S: Fallible + ?Sized, const R: usize, const C: usize> Serialize<S>
+        for ArrayStorage<T, R, C>
+    {
+        fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
+            Ok(self.0.serialize(serializer)?)
+        }
+    }
+
+    impl<T: Archive, D: Fallible + ?Sized, const R: usize, const C: usize>
+        Deserialize<ArrayStorage<T, R, C>, D> for ArrayStorage<T::Archived, R, C>
+    where
+        T::Archived: Deserialize<T, D>,
+    {
+        fn deserialize(&self, deserializer: &mut D) -> Result<ArrayStorage<T, R, C>, D::Error> {
+            Ok(ArrayStorage(self.0.deserialize(deserializer)?))
+        }
+    }
+}

src/base/dimension.rs

@@ -231,6 +231,37 @@ impl<'de, const D: usize> Deserialize<'de> for Const<D> {
     }
 }
 
+#[cfg(feature = "rkyv-serialize-no-std")]
+mod rkyv_impl {
+    use super::Const;
+    use rkyv::{Archive, Deserialize, Fallible, Serialize};
+
+    impl<const R: usize> Archive for Const<R> {
+        type Archived = Self;
+        type Resolver = ();
+
+        fn resolve(
+            &self,
+            _: usize,
+            _: Self::Resolver,
+            _: &mut core::mem::MaybeUninit<Self::Archived>,
+        ) {
+        }
+    }
+
+    impl<S: Fallible + ?Sized, const R: usize> Serialize<S> for Const<R> {
+        fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
+            Ok(())
+        }
+    }
+
+    impl<D: Fallible + ?Sized, const R: usize> Deserialize<Self, D> for Const<R> {
+        fn deserialize(&self, _: &mut D) -> Result<Self, D::Error> {
+            Ok(Const)
+        }
+    }
+}
+
 pub trait ToConst {
     type Const: DimName;
 }

src/base/matrix.rs

@@ -308,6 +308,53 @@ where
 {
 }
 
+#[cfg(feature = "rkyv-serialize-no-std")]
+mod rkyv_impl {
+    use super::Matrix;
+    use core::marker::PhantomData;
+    use rkyv::{offset_of, project_struct, Archive, Deserialize, Fallible, Serialize};
+
+    impl<T: Archive, R: Archive, C: Archive, S: Archive> Archive for Matrix<T, R, C, S> {
+        type Archived = Matrix<T::Archived, R::Archived, C::Archived, S::Archived>;
+        type Resolver = S::Resolver;
+
+        fn resolve(
+            &self,
+            pos: usize,
+            resolver: Self::Resolver,
+            out: &mut core::mem::MaybeUninit<Self::Archived>,
+        ) {
+            self.data.resolve(
+                pos + offset_of!(Self::Archived, data),
+                resolver,
+                project_struct!(out: Self::Archived => data),
+            );
+        }
+    }
+
+    impl<T: Archive, R: Archive, C: Archive, S: Serialize<_S>, _S: Fallible + ?Sized> Serialize<_S>
+        for Matrix<T, R, C, S>
+    {
+        fn serialize(&self, serializer: &mut _S) -> Result<Self::Resolver, _S::Error> {
+            Ok(self.data.serialize(serializer)?)
+        }
+    }
+
+    impl<T: Archive, R: Archive, C: Archive, S: Archive, D: Fallible + ?Sized>
+        Deserialize<Matrix<T, R, C, S>, D>
+        for Matrix<T::Archived, R::Archived, C::Archived, S::Archived>
+    where
+        S::Archived: Deserialize<S, D>,
+    {
+        fn deserialize(&self, deserializer: &mut D) -> Result<Matrix<T, R, C, S>, D::Error> {
+            Ok(Matrix {
+                data: self.data.deserialize(deserializer)?,
+                _phantoms: PhantomData,
+            })
+        }
+    }
+}
+
 impl<T, R, C, S> Matrix<T, R, C, S> {
     /// Creates a new matrix with the given data without statically checking that the matrix
     /// dimension matches the storage dimension.

src/base/unit.rs

@@ -71,6 +71,47 @@ impl<T: Abomonation> Abomonation for Unit<T> {
     }
 }
 
+#[cfg(feature = "rkyv-serialize-no-std")]
+mod rkyv_impl {
+    use super::Unit;
+    use rkyv::{offset_of, project_struct, Archive, Deserialize, Fallible, Serialize};
+
+    impl<T: Archive> Archive for Unit<T> {
+        type Archived = Unit<T::Archived>;
+        type Resolver = T::Resolver;
+
+        fn resolve(
+            &self,
+            pos: usize,
+            resolver: Self::Resolver,
+            out: &mut ::core::mem::MaybeUninit<Self::Archived>,
+        ) {
+            self.value.resolve(
+                pos + offset_of!(Self::Archived, value),
+                resolver,
+                project_struct!(out: Self::Archived => value),
+            );
+        }
+    }
+
+    impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for Unit<T> {
+        fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
+            Ok(self.value.serialize(serializer)?)
+        }
+    }
+
+    impl<T: Archive, D: Fallible + ?Sized> Deserialize<Unit<T>, D> for Unit<T::Archived>
+    where
+        T::Archived: Deserialize<T, D>,
+    {
+        fn deserialize(&self, deserializer: &mut D) -> Result<Unit<T>, D::Error> {
+            Ok(Unit {
+                value: self.value.deserialize(deserializer)?,
+            })
+        }
+    }
+}
+
 impl<T, R, C, S> PartialEq for Unit<Matrix<T, R, C, S>>
 where
     T: Scalar + PartialEq,

src/geometry/isometry.rs

@@ -98,6 +98,66 @@ where
     }
 }
 
+#[cfg(feature = "rkyv-serialize-no-std")]
+mod rkyv_impl {
+    use super::Isometry;
+    use crate::{base::Scalar, geometry::Translation};
+    use rkyv::{offset_of, project_struct, Archive, Deserialize, Fallible, Serialize};
+
+    impl<T: Scalar + Archive, R: Archive, const D: usize> Archive for Isometry<T, R, D>
+    where
+        T::Archived: Scalar,
+    {
+        type Archived = Isometry<T::Archived, R::Archived, D>;
+        type Resolver = (R::Resolver, <Translation<T, D> as Archive>::Resolver);
+
+        fn resolve(
+            &self,
+            pos: usize,
+            resolver: Self::Resolver,
+            out: &mut core::mem::MaybeUninit<Self::Archived>,
+        ) {
+            self.rotation.resolve(
+                pos + offset_of!(Self::Archived, rotation),
+                resolver.0,
+                project_struct!(out: Self::Archived => rotation),
+            );
+            self.translation.resolve(
+                pos + offset_of!(Self::Archived, translation),
+                resolver.1,
+                project_struct!(out: Self::Archived => translation),
+            );
+        }
+    }
+
+    impl<T: Scalar + Serialize<S>, R: Serialize<S>, S: Fallible + ?Sized, const D: usize>
+        Serialize<S> for Isometry<T, R, D>
+    where
+        T::Archived: Scalar,
+    {
+        fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
+            Ok((
+                self.rotation.serialize(serializer)?,
+                self.translation.serialize(serializer)?,
+            ))
+        }
+    }
+
+    impl<T: Scalar + Archive, R: Archive, _D: Fallible + ?Sized, const D: usize>
+        Deserialize<Isometry<T, R, D>, _D> for Isometry<T::Archived, R::Archived, D>
+    where
+        T::Archived: Scalar + Deserialize<T, _D>,
+        R::Archived: Scalar + Deserialize<R, _D>,
+    {
+        fn deserialize(&self, deserializer: &mut _D) -> Result<Isometry<T, R, D>, _D::Error> {
+            Ok(Isometry {
+                rotation: self.rotation.deserialize(deserializer)?,
+                translation: self.translation.deserialize(deserializer)?,
+            })
+        }
+    }
+}
+
 impl<T: Scalar + hash::Hash, R: hash::Hash, const D: usize> hash::Hash for Isometry<T, R, D>
 where
     Owned<T, Const<D>>: hash::Hash,

src/geometry/quaternion.rs

@@ -113,6 +113,48 @@ where
     }
 }
 
+#[cfg(feature = "rkyv-serialize-no-std")]
+mod rkyv_impl {
+    use super::Quaternion;
+    use crate::base::Vector4;
+    use rkyv::{offset_of, project_struct, Archive, Deserialize, Fallible, Serialize};
+
+    impl<T: Archive> Archive for Quaternion<T> {
+        type Archived = Quaternion<T::Archived>;
+        type Resolver = <Vector4<T> as Archive>::Resolver;
+
+        fn resolve(
+            &self,
+            pos: usize,
+            resolver: Self::Resolver,
+            out: &mut core::mem::MaybeUninit<Self::Archived>,
+        ) {
+            self.coords.resolve(
+                pos + offset_of!(Self::Archived, coords),
+                resolver,
+                project_struct!(out: Self::Archived => coords),
+            );
+        }
+    }
+
+    impl<T: Serialize<S>, S: Fallible + ?Sized> Serialize<S> for Quaternion<T> {
+        fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
+            Ok(self.coords.serialize(serializer)?)
+        }
+    }
+
+    impl<T: Archive, D: Fallible + ?Sized> Deserialize<Quaternion<T>, D> for Quaternion<T::Archived>
+    where
+        T::Archived: Deserialize<T, D>,
+    {
+        fn deserialize(&self, deserializer: &mut D) -> Result<Quaternion<T>, D::Error> {
+            Ok(Quaternion {
+                coords: self.coords.deserialize(deserializer)?,
+            })
+        }
+    }
+}
+
 impl<T: SimdRealField> Quaternion<T>
 where
     T::Element: SimdRealField,

src/geometry/translation.rs

@@ -97,6 +97,49 @@ where
     }
 }
 
+#[cfg(feature = "rkyv-serialize-no-std")]
+mod rkyv_impl {
+    use super::Translation;
+    use crate::base::SVector;
+    use rkyv::{offset_of, project_struct, Archive, Deserialize, Fallible, Serialize};
+
+    impl<T: Archive, const D: usize> Archive for Translation<T, D> {
+        type Archived = Translation<T::Archived, D>;
+        type Resolver = <SVector<T, D> as Archive>::Resolver;
+
+        fn resolve(
+            &self,
+            pos: usize,
+            resolver: Self::Resolver,
+            out: &mut core::mem::MaybeUninit<Self::Archived>,
+        ) {
+            self.vector.resolve(
+                pos + offset_of!(Self::Archived, vector),
+                resolver,
+                project_struct!(out: Self::Archived => vector),
+            );
+        }
+    }
+
+    impl<T: Serialize<S>, S: Fallible + ?Sized, const D: usize> Serialize<S> for Translation<T, D> {
+        fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
+            Ok(self.vector.serialize(serializer)?)
+        }
+    }
+
+    impl<T: Archive, _D: Fallible + ?Sized, const D: usize> Deserialize<Translation<T, D>, _D>
+        for Translation<T::Archived, D>
+    where
+        T::Archived: Deserialize<T, _D>,
+    {
+        fn deserialize(&self, deserializer: &mut _D) -> Result<Translation<T, D>, _D::Error> {
+            Ok(Translation {
+                vector: self.vector.deserialize(deserializer)?,
+            })
+        }
+    }
+}
+
 impl<T: Scalar, const D: usize> Translation<T, D> {
     /// Creates a new translation from the given vector.
     #[inline]