From 9fff10b1f08f76aabc0a7ad8039eeae22020229c Mon Sep 17 00:00:00 2001
From: David Koloski <djkoloski@gmail.com>
Date: Sun, 9 May 2021 11:28:49 -0400
Subject: [PATCH] Move rkyv impls into separate modules

---
 src/base/array_storage.rs   | 66 ++++++++++++++------------
 src/base/dimension.rs       | 39 ++++++++-------
 src/base/matrix.rs          | 66 +++++++++++++++-----------
 src/base/unit.rs            | 59 ++++++++++++-----------
 src/geometry/isometry.rs    | 94 ++++++++++++++++++++-----------------
 src/geometry/quaternion.rs  | 60 ++++++++++++-----------
 src/geometry/translation.rs | 61 +++++++++++++-----------
 7 files changed, 247 insertions(+), 198 deletions(-)

diff --git a/src/base/array_storage.rs b/src/base/array_storage.rs
index 350240cd..6d681ed5 100644
--- a/src/base/array_storage.rs
+++ b/src/base/array_storage.rs
@@ -18,9 +18,6 @@ use std::mem;
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-use rkyv::{Archive, Deserialize, Serialize};
-
 use crate::base::allocator::Allocator;
 use crate::base::default_allocator::DefaultAllocator;
 use crate::base::dimension::{Const, ToTypenum};
@@ -304,32 +301,43 @@ where
 }
 
 #[cfg(feature = "rkyv-serialize-no-std")]
-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;
+mod rkyv_impl {
+    use super::ArrayStorage;
+    use rkyv::{offset_of, project_struct, Archive, Deserialize, Fallible, Serialize};
 
-    fn resolve(&self, pos: usize, resolver: Self::Resolver, out: &mut core::mem::MaybeUninit<Self::Archived>) {
-        self.0.resolve(
-            pos + rkyv::offset_of!(Self::Archived, 0),
-            resolver,
-            rkyv::project_struct!(out: Self::Archived => 0)
-        );
-    }
-}
-
-#[cfg(feature = "rkyv-serialize-no-std")]
-impl<T: Serialize<S>, S: rkyv::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)?)
-    }
-}
-
-#[cfg(feature = "rkyv-serialize-no-std")]
-impl<T: Archive, D: rkyv::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)?))
+    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)?))
+        }
     }
 }
diff --git a/src/base/dimension.rs b/src/base/dimension.rs
index 3ee762f1..2b5ccec3 100644
--- a/src/base/dimension.rs
+++ b/src/base/dimension.rs
@@ -11,9 +11,6 @@ use typenum::{self, Diff, Max, Maximum, Min, Minimum, Prod, Quot, Sum, Unsigned}
 #[cfg(feature = "serde-serialize-no-std")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-use rkyv::{Archive, Deserialize, Serialize};
-
 /// Dim of dynamically-sized algebraic entities.
 #[derive(Clone, Copy, Eq, PartialEq, Debug)]
 pub struct Dynamic {
@@ -235,25 +232,33 @@ impl<'de, const D: usize> Deserialize<'de> for Const<D> {
 }
 
 #[cfg(feature = "rkyv-serialize-no-std")]
-impl<const R: usize> Archive for Const<R> {
-    type Archived = Self;
-    type Resolver = ();
+mod rkyv_impl {
+    use super::Const;
+    use rkyv::{Archive, Deserialize, Fallible, Serialize};
 
-    fn resolve(&self, _: usize, _: Self::Resolver, _: &mut core::mem::MaybeUninit<Self::Archived>) {
+    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>,
+        ) {
+        }
     }
-}
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-impl<S: rkyv::Fallible + ?Sized, const R: usize> Serialize<S> for Const<R> {
-    fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
-        Ok(())
+    impl<S: Fallible + ?Sized, const R: usize> Serialize<S> for Const<R> {
+        fn serialize(&self, _: &mut S) -> Result<Self::Resolver, S::Error> {
+            Ok(())
+        }
     }
-}
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-impl<D: rkyv::Fallible + ?Sized, const R: usize> Deserialize<Self, D> for Const<R> {
-    fn deserialize(&self, _: &mut D) -> Result<Self, D::Error> {
-        Ok(Const)
+    impl<D: Fallible + ?Sized, const R: usize> Deserialize<Self, D> for Const<R> {
+        fn deserialize(&self, _: &mut D) -> Result<Self, D::Error> {
+            Ok(Const)
+        }
     }
 }
 
diff --git a/src/base/matrix.rs b/src/base/matrix.rs
index 939e78b3..bc9942be 100644
--- a/src/base/matrix.rs
+++ b/src/base/matrix.rs
@@ -16,9 +16,6 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-use rkyv::{Archive, Deserialize, Serialize};
-
 use simba::scalar::{ClosedAdd, ClosedMul, ClosedSub, Field, SupersetOf};
 use simba::simd::SimdPartialOrd;
 
@@ -312,36 +309,49 @@ where
 }
 
 #[cfg(feature = "rkyv-serialize-no-std")]
-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;
+mod rkyv_impl {
+    use super::Matrix;
+    use core::marker::PhantomData;
+    use rkyv::{offset_of, project_struct, Archive, Deserialize, Fallible, Serialize};
 
-    fn resolve(&self, pos: usize, resolver: Self::Resolver, out: &mut core::mem::MaybeUninit<Self::Archived>) {
-        self.data.resolve(
-            pos + rkyv::offset_of!(Self::Archived, data),
-            resolver,
-            rkyv::project_struct!(out: Self::Archived => data)
-        );
+    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),
+            );
+        }
     }
-}
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-impl<T: Archive, R: Archive, C: Archive, S: Serialize<_S>, _S: rkyv::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: 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)?)
+        }
     }
-}
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-impl<T: Archive, R: Archive, C: Archive, S: Archive, D: rkyv::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: 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,
+            })
+        }
     }
 }
 
diff --git a/src/base/unit.rs b/src/base/unit.rs
index 0c30f961..b5a4096f 100644
--- a/src/base/unit.rs
+++ b/src/base/unit.rs
@@ -6,9 +6,6 @@ use std::ops::Deref;
 #[cfg(feature = "serde-serialize-no-std")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-use rkyv::{Archive, Deserialize, Serialize};
-
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
@@ -75,35 +72,43 @@ impl<T: Abomonation> Abomonation for Unit<T> {
 }
 
 #[cfg(feature = "rkyv-serialize-no-std")]
-impl<T: Archive> Archive for Unit<T> {
-    type Archived = Unit<T::Archived>;
-    type Resolver = T::Resolver;
+mod rkyv_impl {
+    use super::Unit;
+    use rkyv::{offset_of, project_struct, Archive, Deserialize, Fallible, Serialize};
 
-    fn resolve(&self, pos: usize, resolver: Self::Resolver, out: &mut ::core::mem::MaybeUninit<Self::Archived>) {
-        self.value.resolve(
-            pos + rkyv::offset_of!(Self::Archived, value),
-            resolver,
-            rkyv::project_struct!(out: Self::Archived => value),
-        );
+    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),
+            );
+        }
     }
-}
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-impl<T: Serialize<S>, S: rkyv::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: 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)?)
+        }
     }
-}
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-impl<T: Archive, D: rkyv::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: 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)?,
+            })
+        }
     }
 }
 
diff --git a/src/geometry/isometry.rs b/src/geometry/isometry.rs
index dea1b1be..d307c393 100755
--- a/src/geometry/isometry.rs
+++ b/src/geometry/isometry.rs
@@ -7,9 +7,6 @@ use std::io::{Result as IOResult, Write};
 #[cfg(feature = "serde-serialize-no-std")]
 use serde::{Deserialize, Serialize};
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-use rkyv::{Archive, Deserialize, Serialize};
-
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
@@ -102,51 +99,62 @@ where
 }
 
 #[cfg(feature = "rkyv-serialize-no-std")]
-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);
+mod rkyv_impl {
+    use super::Isometry;
+    use crate::{base::Scalar, geometry::Translation};
+    use rkyv::{offset_of, project_struct, Archive, Deserialize, Fallible, Serialize};
 
-    fn resolve(&self, pos: usize, resolver: Self::Resolver, out: &mut core::mem::MaybeUninit<Self::Archived>) {
-        self.rotation.resolve(
-            pos + rkyv::offset_of!(Self::Archived, rotation),
-            resolver.0,
-            rkyv::project_struct!(out: Self::Archived => rotation)
-        );
-        self.translation.resolve(
-            pos + rkyv::offset_of!(Self::Archived, translation),
-            resolver.1,
-            rkyv::project_struct!(out: Self::Archived => translation)
-        );
+    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),
+            );
+        }
     }
-}
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-impl<T: Scalar + Serialize<S>, R: Serialize<S>, S: rkyv::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 + 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)?,
+            ))
+        }
     }
-}
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-impl<T: Scalar + Archive, R: Archive, _D: rkyv::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 + 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)?,
+            })
+        }
     }
 }
 
diff --git a/src/geometry/quaternion.rs b/src/geometry/quaternion.rs
index 7c6a70ae..6852335b 100755
--- a/src/geometry/quaternion.rs
+++ b/src/geometry/quaternion.rs
@@ -10,9 +10,6 @@ use crate::base::storage::Owned;
 #[cfg(feature = "serde-serialize-no-std")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-use rkyv::{Archive, Deserialize, Serialize};
-
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
@@ -117,35 +114,44 @@ where
 }
 
 #[cfg(feature = "rkyv-serialize-no-std")]
-impl<T: Archive> Archive for Quaternion<T> {
-    type Archived = Quaternion<T::Archived>;
-    type Resolver = <Vector4<T> as Archive>::Resolver;
+mod rkyv_impl {
+    use super::Quaternion;
+    use crate::base::Vector4;
+    use rkyv::{offset_of, project_struct, Archive, Deserialize, Fallible, Serialize};
 
-    fn resolve(&self, pos: usize, resolver: Self::Resolver, out: &mut core::mem::MaybeUninit<Self::Archived>) {
-        self.coords.resolve(
-            pos + rkyv::offset_of!(Self::Archived, coords),
-            resolver,
-            rkyv::project_struct!(out: Self::Archived => coords)
-        );
+    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),
+            );
+        }
     }
-}
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-impl<T: Serialize<S>, S: rkyv::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: 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)?)
+        }
     }
-}
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-impl<T: Archive, D: rkyv::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: 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)?,
+            })
+        }
     }
 }
 
diff --git a/src/geometry/translation.rs b/src/geometry/translation.rs
index 7f3665ae..dcb7b603 100755
--- a/src/geometry/translation.rs
+++ b/src/geometry/translation.rs
@@ -8,9 +8,6 @@ use std::io::{Result as IOResult, Write};
 #[cfg(feature = "serde-serialize-no-std")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-use rkyv::{Archive, Deserialize, Serialize};
-
 #[cfg(feature = "abomonation-serialize")]
 use abomonation::Abomonation;
 
@@ -101,35 +98,45 @@ where
 }
 
 #[cfg(feature = "rkyv-serialize-no-std")]
-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;
+mod rkyv_impl {
+    use super::Translation;
+    use crate::base::SVector;
+    use rkyv::{offset_of, project_struct, Archive, Deserialize, Fallible, Serialize};
 
-    fn resolve(&self, pos: usize, resolver: Self::Resolver, out: &mut core::mem::MaybeUninit<Self::Archived>) {
-        self.vector.resolve(
-            pos + rkyv::offset_of!(Self::Archived, vector),
-            resolver,
-            rkyv::project_struct!(out: Self::Archived => vector)
-        );
+    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),
+            );
+        }
     }
-}
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-impl<T: Serialize<S>, S: rkyv::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: 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)?)
+        }
     }
-}
 
-#[cfg(feature = "rkyv-serialize-no-std")]
-impl<T: Archive, _D: rkyv::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: 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)?,
+            })
+        }
     }
 }