diff --git a/Engine/Source/Common/Include/Common/Math/Box.h b/Engine/Source/Common/Include/Common/Math/Box.h
index 7d8654e6..42909de3 100644
--- a/Engine/Source/Common/Include/Common/Math/Box.h
+++ b/Engine/Source/Common/Include/Common/Math/Box.h
@@ -55,27 +55,20 @@ namespace Common {
 namespace Common { // NOLINT
     template <Serializable T>
     struct Serializer<Box<T>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("Common::Box")
             + Serializer<T>::typeId;
 
-        static void Serialize(SerializeStream& stream, const Box<T>& value)
+        static size_t Serialize(SerializeStream& stream, const Box<T>& value)
         {
-            TypeIdSerializer<Box<T>>::Serialize(stream);
-
-            Serializer<Vec<T, 3>>::Serialize(stream, value.min);
-            Serializer<Vec<T, 3>>::Serialize(stream, value.max);
+            return Serializer<Vec<T, 3>>::Serialize(stream, value.min)
+                + Serializer<Vec<T, 3>>::Serialize(stream, value.max);
         }
 
-        static bool Deserialize(DeserializeStream& stream, Box<T>& value)
+        static size_t Deserialize(DeserializeStream& stream, Box<T>& value)
         {
-            if (!TypeIdSerializer<Box<T>>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<Vec<T, 3>>::Deserialize(stream, value.min);
-            Serializer<Vec<T, 3>>::Deserialize(stream, value.max);
-            return true;
+            return Serializer<Vec<T, 3>>::Deserialize(stream, value.min)
+                + Serializer<Vec<T, 3>>::Deserialize(stream, value.max);
         }
     };
 
diff --git a/Engine/Source/Common/Include/Common/Math/Color.h b/Engine/Source/Common/Include/Common/Math/Color.h
index 220ec084..3dde1132 100644
--- a/Engine/Source/Common/Include/Common/Math/Color.h
+++ b/Engine/Source/Common/Include/Common/Math/Color.h
@@ -71,57 +71,43 @@ namespace Common {
 namespace Common {
     template <>
     struct Serializer<Color> {
-        static constexpr uint32_t typeId = HashUtils::StrCrc32("Common::Color");
+        static constexpr size_t typeId = HashUtils::StrCrc32("Common::Color");
 
-        static void Serialize(SerializeStream& stream, const Color& value)
+        static size_t Serialize(SerializeStream& stream, const Color& value)
         {
-            TypeIdSerializer<Color>::Serialize(stream);
-
-            Serializer<uint8_t>::Serialize(stream, value.r);
-            Serializer<uint8_t>::Serialize(stream, value.g);
-            Serializer<uint8_t>::Serialize(stream, value.b);
-            Serializer<uint8_t>::Serialize(stream, value.a);
+            return Serializer<uint8_t>::Serialize(stream, value.r)
+                + Serializer<uint8_t>::Serialize(stream, value.g)
+                + Serializer<uint8_t>::Serialize(stream, value.b)
+                + Serializer<uint8_t>::Serialize(stream, value.a);
         }
 
-        static bool Deserialize(DeserializeStream& stream, Color& value)
+        static size_t Deserialize(DeserializeStream& stream, Color& value)
         {
-            if (!TypeIdSerializer<Color>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<uint8_t>::Deserialize(stream, value.r);
-            Serializer<uint8_t>::Deserialize(stream, value.g);
-            Serializer<uint8_t>::Deserialize(stream, value.b);
-            Serializer<uint8_t>::Deserialize(stream, value.a);
-            return true;
+            return Serializer<uint8_t>::Deserialize(stream, value.r)
+                + Serializer<uint8_t>::Deserialize(stream, value.g)
+                + Serializer<uint8_t>::Deserialize(stream, value.b)
+                + Serializer<uint8_t>::Deserialize(stream, value.a);
         }
     };
 
     template <>
     struct Serializer<LinearColor> {
-        static constexpr uint32_t typeId = HashUtils::StrCrc32("Common::LinearColor");
+        static constexpr size_t typeId = HashUtils::StrCrc32("Common::LinearColor");
 
-        static void Serialize(SerializeStream& stream, const LinearColor& value)
+        static size_t Serialize(SerializeStream& stream, const LinearColor& value)
         {
-            TypeIdSerializer<Color>::Serialize(stream);
-
-            Serializer<float>::Serialize(stream, value.r);
-            Serializer<float>::Serialize(stream, value.g);
-            Serializer<float>::Serialize(stream, value.b);
-            Serializer<float>::Serialize(stream, value.a);
+            return Serializer<float>::Serialize(stream, value.r)
+                + Serializer<float>::Serialize(stream, value.g)
+                + Serializer<float>::Serialize(stream, value.b)
+                + Serializer<float>::Serialize(stream, value.a);
         }
 
-        static bool Deserialize(DeserializeStream& stream, LinearColor& value)
+        static size_t Deserialize(DeserializeStream& stream, LinearColor& value)
         {
-            if (!TypeIdSerializer<Color>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<float>::Deserialize(stream, value.r);
-            Serializer<float>::Deserialize(stream, value.g);
-            Serializer<float>::Deserialize(stream, value.b);
-            Serializer<float>::Deserialize(stream, value.a);
-            return true;
+            return Serializer<float>::Deserialize(stream, value.r)
+                + Serializer<float>::Deserialize(stream, value.g)
+                + Serializer<float>::Deserialize(stream, value.b)
+                + Serializer<float>::Deserialize(stream, value.a);
         }
     };
 
diff --git a/Engine/Source/Common/Include/Common/Math/Half.h b/Engine/Source/Common/Include/Common/Math/Half.h
index 95bf4d44..5b857106 100644
--- a/Engine/Source/Common/Include/Common/Math/Half.h
+++ b/Engine/Source/Common/Include/Common/Math/Half.h
@@ -84,45 +84,31 @@ namespace Common {
 namespace Common {
     template <std::endian E>
     struct Serializer<Internal::FullFloat<E>> {
-        static constexpr uint32_t typeId = HashUtils::StrCrc32("Common::Internal::FullFloat");
+        static constexpr size_t typeId = HashUtils::StrCrc32("Common::Internal::FullFloat");
 
-        static void Serialize(SerializeStream& stream, const Internal::FullFloat<E>& value)
+        static size_t Serialize(SerializeStream& stream, const Internal::FullFloat<E>& value)
         {
-            TypeIdSerializer<Internal::FullFloat<E>>::Serialize(stream);
-
-            Serializer<float>::Serialize(stream, value.value);
+            return Serializer<float>::Serialize(stream, value.value);
         }
 
-        static bool Deserialize(DeserializeStream& stream, Internal::FullFloat<E>& value)
+        static size_t Deserialize(DeserializeStream& stream, Internal::FullFloat<E>& value)
         {
-            if (!TypeIdSerializer<Internal::FullFloat<E>>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<float>::Deserialize(stream, value.value);
-            return true;
+            return Serializer<float>::Deserialize(stream, value.value);
         }
     };
 
     template <std::endian E>
     struct Serializer<HalfFloat<E>> {
-        static constexpr uint32_t typeId = HashUtils::StrCrc32("Common::Internal::HalfFloat");
+        static constexpr size_t typeId = HashUtils::StrCrc32("Common::Internal::HalfFloat");
 
-        static void Serialize(SerializeStream& stream, const HalfFloat<E>& value)
+        static size_t Serialize(SerializeStream& stream, const HalfFloat<E>& value)
         {
-            TypeIdSerializer<HalfFloat<E>>::Serialize(stream);
-
-            Serializer<uint16_t>::Serialize(stream, value.value);
+            return Serializer<uint16_t>::Serialize(stream, value.value);
         }
 
-        static bool Deserialize(DeserializeStream& stream, HalfFloat<E>& value)
+        static size_t Deserialize(DeserializeStream& stream, HalfFloat<E>& value)
         {
-            if (!TypeIdSerializer<HalfFloat<E>>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<uint16_t>::Deserialize(stream, value.value);
-            return true;
+            return Serializer<uint16_t>::Deserialize(stream, value.value);
         }
     };
 
diff --git a/Engine/Source/Common/Include/Common/Math/Matrix.h b/Engine/Source/Common/Include/Common/Math/Matrix.h
index 173e68ad..b09eee6c 100644
--- a/Engine/Source/Common/Include/Common/Math/Matrix.h
+++ b/Engine/Source/Common/Include/Common/Math/Matrix.h
@@ -304,29 +304,26 @@ namespace Common {
 namespace Common { // NOLINT
     template <Serializable T, uint8_t R, uint8_t C>
     struct Serializer<Mat<T, R, C>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("Common::Matrix")
             + Serializer<T>::typeId + (R << 8) + C;
 
-        static void Serialize(SerializeStream& stream, const Mat<T, R, C>& value)
+        static size_t Serialize(SerializeStream& stream, const Mat<T, R, C>& value)
         {
-            TypeIdSerializer<Mat<T, R, C>>::Serialize(stream);
-
+            auto serialized = 0;
             for (auto i = 0; i < R * C; i++) {
-                Serializer<T>::Serialize(stream, value.data[i]);
+                serialized += Serializer<T>::Serialize(stream, value.data[i]);
             }
+            return serialized;
         }
 
-        static bool Deserialize(DeserializeStream& stream, Mat<T, R, C>& value)
+        static size_t Deserialize(DeserializeStream& stream, Mat<T, R, C>& value)
         {
-            if (!TypeIdSerializer<Mat<T, R, C>>::Deserialize(stream)) {
-                return false;
-            }
-
+            auto deserialized = 0;
             for (auto i = 0; i < R * C; i++) {
-                Serializer<T>::Deserialize(stream, value.data[i]);
+                deserialized += Serializer<T>::Deserialize(stream, value.data[i]);
             }
-            return true;
+            return deserialized;
         }
     };
 
diff --git a/Engine/Source/Common/Include/Common/Math/Projection.h b/Engine/Source/Common/Include/Common/Math/Projection.h
index e315026d..555e08b5 100644
--- a/Engine/Source/Common/Include/Common/Math/Projection.h
+++ b/Engine/Source/Common/Include/Common/Math/Projection.h
@@ -61,63 +61,49 @@ namespace Common {
 namespace Common {
     template <Serializable T>
     struct Serializer<ReversedZOrthogonalProjection<T>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("Common::ReversedZOrthogonalProjection")
             + Serializer<T>::typeId;
 
-        static void Serialize(SerializeStream& stream, const ReversedZOrthogonalProjection<T>& value)
+        static size_t Serialize(SerializeStream& stream, const ReversedZOrthogonalProjection<T>& value)
         {
-            TypeIdSerializer<ReversedZOrthogonalProjection<T>>::Serialize(stream);
-
-            Serializer<T>::Serialize(stream, value.width);
-            Serializer<T>::Serialize(stream, value.height);
-            Serializer<T>::Serialize(stream, value.nearPlane);
-            Serializer<std::optional<T>>::Serialize(stream, value.farPlane);
+            return Serializer<T>::Serialize(stream, value.width)
+                + Serializer<T>::Serialize(stream, value.height)
+                + Serializer<T>::Serialize(stream, value.nearPlane)
+                + Serializer<std::optional<T>>::Serialize(stream, value.farPlane);
         }
 
-        static bool Deserialize(DeserializeStream& stream, ReversedZOrthogonalProjection<T>& value)
+        static size_t Deserialize(DeserializeStream& stream, ReversedZOrthogonalProjection<T>& value)
         {
-            if (!TypeIdSerializer<ReversedZOrthogonalProjection<T>>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<T>::Deserialize(stream, value.width);
-            Serializer<T>::Deserialize(stream, value.height);
-            Serializer<T>::Deserialize(stream, value.nearPlane);
-            Serializer<std::optional<T>>::Deserialize(stream, value.farPlane);
-            return true;
+            return Serializer<T>::Deserialize(stream, value.width)
+                + Serializer<T>::Deserialize(stream, value.height)
+                + Serializer<T>::Deserialize(stream, value.nearPlane)
+                + Serializer<std::optional<T>>::Deserialize(stream, value.farPlane);
         }
     };
 
     template <Serializable T>
     struct Serializer<ReversedZPerspectiveProjection<T>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("Common::ReversedZPerspectiveProjection")
             + Serializer<T>::typeId;
 
-        static void Serialize(SerializeStream& stream, const ReversedZPerspectiveProjection<T>& value)
+        static size_t Serialize(SerializeStream& stream, const ReversedZPerspectiveProjection<T>& value)
         {
-            TypeIdSerializer<ReversedZPerspectiveProjection<T>>::Serialize(stream);
-
-            Serializer<T>::Serialize(stream, value.fov);
-            Serializer<T>::Serialize(stream, value.width);
-            Serializer<T>::Serialize(stream, value.height);
-            Serializer<T>::Serialize(stream, value.nearPlane);
-            Serializer<std::optional<T>>::Serialize(stream, value.farPlane);
+            return Serializer<T>::Serialize(stream, value.fov)
+                + Serializer<T>::Serialize(stream, value.width)
+                + Serializer<T>::Serialize(stream, value.height)
+                + Serializer<T>::Serialize(stream, value.nearPlane)
+                + Serializer<std::optional<T>>::Serialize(stream, value.farPlane);
         }
 
-        static bool Deserialize(DeserializeStream& stream, ReversedZPerspectiveProjection<T>& value)
+        static size_t Deserialize(DeserializeStream& stream, ReversedZPerspectiveProjection<T>& value)
         {
-            if (!TypeIdSerializer<ReversedZPerspectiveProjection<T>>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<T>::Deserialize(stream, value.fov);
-            Serializer<T>::Deserialize(stream, value.width);
-            Serializer<T>::Deserialize(stream, value.height);
-            Serializer<T>::Deserialize(stream, value.nearPlane);
-            Serializer<std::optional<T>>::Deserialize(stream, value.farPlane);
-            return true;
+            return Serializer<T>::Deserialize(stream, value.fov)
+                + Serializer<T>::Deserialize(stream, value.width)
+                + Serializer<T>::Deserialize(stream, value.height)
+                + Serializer<T>::Deserialize(stream, value.nearPlane)
+                + Serializer<std::optional<T>>::Deserialize(stream, value.farPlane);
         }
     };
 
diff --git a/Engine/Source/Common/Include/Common/Math/Quaternion.h b/Engine/Source/Common/Include/Common/Math/Quaternion.h
index 45c2d6fc..c7cb3207 100644
--- a/Engine/Source/Common/Include/Common/Math/Quaternion.h
+++ b/Engine/Source/Common/Include/Common/Math/Quaternion.h
@@ -123,79 +123,58 @@ namespace Common {
 namespace Common {
     template <Serializable T>
     struct Serializer<Angle<T>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("Common::Angle")
             + Serializer<T>::typeId;
 
-        static void Serialize(SerializeStream& stream, const Angle<T>& value)
+        static size_t Serialize(SerializeStream& stream, const Angle<T>& value)
         {
-            TypeIdSerializer<Angle<T>>::Serialize(stream);
-
-            Serializer<T>::Serialize(stream, value.value);
+            return Serializer<T>::Serialize(stream, value.value);
         }
 
-        static bool Deserialize(DeserializeStream& stream, Angle<T>& value)
+        static size_t Deserialize(DeserializeStream& stream, Angle<T>& value)
         {
-            if (!TypeIdSerializer<Angle<T>>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<T>::Deserialize(stream, value.value);
-            return true;
+            return Serializer<T>::Deserialize(stream, value.value);
         }
     };
 
     template <Serializable T>
     struct Serializer<Radian<T>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("Common::Radian")
             + Serializer<T>::typeId;
 
-        static void Serialize(SerializeStream& stream, const Radian<T>& value)
+        static size_t Serialize(SerializeStream& stream, const Radian<T>& value)
         {
-            TypeIdSerializer<Radian<T>>::Serialize(stream);
-
-            Serializer<T>::Serialize(stream, value.value);
+            return Serializer<T>::Serialize(stream, value.value);
         }
 
-        static bool Deserialize(DeserializeStream& stream, Radian<T>& value)
+        static size_t Deserialize(DeserializeStream& stream, Radian<T>& value)
         {
-            if (!TypeIdSerializer<Radian<T>>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<T>::Deserialize(stream, value.value);
-            return true;
+            return Serializer<T>::Deserialize(stream, value.value);
         }
     };
 
     template <Serializable T>
     struct Serializer<Quaternion<T>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("Common::Quaternion")
             + Serializer<T>::typeId;
 
-        static void Serialize(SerializeStream& stream, const Quaternion<T>& value)
+        static size_t Serialize(SerializeStream& stream, const Quaternion<T>& value)
         {
-            TypeIdSerializer<Quaternion<T>>::Serialize(stream);
-
-            Serializer<T>::Serialize(stream, value.x);
-            Serializer<T>::Serialize(stream, value.y);
-            Serializer<T>::Serialize(stream, value.z);
-            Serializer<T>::Serialize(stream, value.w);
+            return Serializer<T>::Serialize(stream, value.x)
+                + Serializer<T>::Serialize(stream, value.y)
+                + Serializer<T>::Serialize(stream, value.z)
+                + Serializer<T>::Serialize(stream, value.w);
         }
 
-        static bool Deserialize(DeserializeStream& stream, Quaternion<T>& value)
+        static size_t Deserialize(DeserializeStream& stream, Quaternion<T>& value)
         {
-            if (!TypeIdSerializer<Quaternion<T>>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<T>::Deserialize(stream, value.x);
-            Serializer<T>::Deserialize(stream, value.y);
-            Serializer<T>::Deserialize(stream, value.z);
-            Serializer<T>::Deserialize(stream, value.w);
-            return true;
+            return Serializer<T>::Deserialize(stream, value.x)
+                + Serializer<T>::Deserialize(stream, value.y)
+                + Serializer<T>::Deserialize(stream, value.z)
+                + Serializer<T>::Deserialize(stream, value.w);
         }
     };
 
diff --git a/Engine/Source/Common/Include/Common/Math/Rect.h b/Engine/Source/Common/Include/Common/Math/Rect.h
index 55466f32..86938445 100644
--- a/Engine/Source/Common/Include/Common/Math/Rect.h
+++ b/Engine/Source/Common/Include/Common/Math/Rect.h
@@ -53,27 +53,20 @@ namespace Common {
 namespace Common {
     template <Serializable T>
     struct Serializer<Rect<T>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("Common::Rect")
             + Serializer<T>::typeId;
 
-        static void Serialize(SerializeStream& stream, const Rect<T>& value)
+        static size_t Serialize(SerializeStream& stream, const Rect<T>& value)
         {
-            TypeIdSerializer<Rect<T>>::Serialize(stream);
-
-            Serializer<Vec<T, 2>>::Serialize(stream, value.min);
-            Serializer<Vec<T, 2>>::Serialize(stream, value.max);
+            return Serializer<Vec<T, 2>>::Serialize(stream, value.min)
+                + Serializer<Vec<T, 2>>::Serialize(stream, value.max);
         }
 
-        static bool Deserialize(DeserializeStream& stream, Rect<T>& value)
+        static size_t Deserialize(DeserializeStream& stream, Rect<T>& value)
         {
-            if (!TypeIdSerializer<Rect<T>>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<Vec<T, 2>>::Deserialize(stream, value.min);
-            Serializer<Vec<T, 2>>::Deserialize(stream, value.max);
-            return true;
+            return Serializer<Vec<T, 2>>::Deserialize(stream, value.min)
+                + Serializer<Vec<T, 2>>::Deserialize(stream, value.max);
         }
     };
 
diff --git a/Engine/Source/Common/Include/Common/Math/Sphere.h b/Engine/Source/Common/Include/Common/Math/Sphere.h
index c816c7b3..f5cee357 100644
--- a/Engine/Source/Common/Include/Common/Math/Sphere.h
+++ b/Engine/Source/Common/Include/Common/Math/Sphere.h
@@ -41,27 +41,20 @@ namespace Common {
 namespace Common {
     template <Serializable T>
     struct Serializer<Sphere<T>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("Common::Sphere")
             + Serializer<T>::typeId;
 
-        static void Serialize(SerializeStream& stream, const Sphere<T>& value)
+        static size_t Serialize(SerializeStream& stream, const Sphere<T>& value)
         {
-            TypeIdSerializer<Sphere<T>>::Serialize(stream);
-
-            Serializer<Vec<T, 3>>::Serialize(stream, value.center);
-            Serializer<T>::Serialize(stream, value.radius);
+            return Serializer<Vec<T, 3>>::Serialize(stream, value.center)
+                + Serializer<T>::Serialize(stream, value.radius);
         }
 
-        static bool Deserialize(DeserializeStream& stream, Sphere<T>& value)
+        static size_t Deserialize(DeserializeStream& stream, Sphere<T>& value)
         {
-            if (!TypeIdSerializer<Sphere<T>>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<Vec<T, 3>>::Deserialize(stream, value.center);
-            Serializer<T>::Deserialize(stream, value.radius);
-            return true;
+            return Serializer<Vec<T, 3>>::Deserialize(stream, value.center)
+                + Serializer<T>::Deserialize(stream, value.radius);
         }
     };
 
diff --git a/Engine/Source/Common/Include/Common/Math/Transform.h b/Engine/Source/Common/Include/Common/Math/Transform.h
index 9425a675..7d5832d0 100644
--- a/Engine/Source/Common/Include/Common/Math/Transform.h
+++ b/Engine/Source/Common/Include/Common/Math/Transform.h
@@ -69,29 +69,22 @@ namespace Common {
 namespace Common {
     template <Serializable T>
     struct Serializer<Transform<T>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("Common::Transform")
             + Serializer<T>::typeId;
 
-        static void Serialize(SerializeStream& stream, const Transform<T>& value)
+        static size_t Serialize(SerializeStream& stream, const Transform<T>& value)
         {
-            TypeIdSerializer<Transform<T>>::Serialize(stream);
-
-            Serializer<Vec<T, 3>>::Serialize(stream, value.scale);
-            Serializer<Quaternion<T>>::Serialize(stream, value.rotation);
-            Serializer<Vec<T, 3>>::Serialize(stream, value.translation);
+            return Serializer<Vec<T, 3>>::Serialize(stream, value.scale)
+                + Serializer<Quaternion<T>>::Serialize(stream, value.rotation)
+                + Serializer<Vec<T, 3>>::Serialize(stream, value.translation);
         }
 
-        static bool Deserialize(DeserializeStream& stream, Transform<T>& value)
+        static size_t Deserialize(DeserializeStream& stream, Transform<T>& value)
         {
-            if (!TypeIdSerializer<Transform<T>>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<Vec<T, 3>>::Deserialize(stream, value.scale);
-            Serializer<Quaternion<T>>::Deserialize(stream, value.rotation);
-            Serializer<Vec<T, 3>>::Deserialize(stream, value.translation);
-            return true;
+            return Serializer<Vec<T, 3>>::Deserialize(stream, value.scale)
+                + Serializer<Quaternion<T>>::Deserialize(stream, value.rotation)
+                + Serializer<Vec<T, 3>>::Deserialize(stream, value.translation);
         }
     };
 
diff --git a/Engine/Source/Common/Include/Common/Math/Vector.h b/Engine/Source/Common/Include/Common/Math/Vector.h
index 834ee14e..aa400b1f 100644
--- a/Engine/Source/Common/Include/Common/Math/Vector.h
+++ b/Engine/Source/Common/Include/Common/Math/Vector.h
@@ -216,30 +216,27 @@ namespace Common::Internal {
 namespace Common {
     template <Serializable T, uint8_t L>
     struct Serializer<Vec<T, L>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = Common::HashUtils::StrCrc32("Common::Vector")
             + Serializer<T>::typeId
             + L;
 
-        static void Serialize(SerializeStream& stream, const Vec<T, L>& value)
+        static size_t Serialize(SerializeStream& stream, const Vec<T, L>& value)
         {
-            TypeIdSerializer<Vec<T, L>>::Serialize(stream);
-
+            size_t serialized = 0;
             for (auto i = 0; i < L; i++) {
-                Serializer<T>::Serialize(stream, value.data[i]);
+                serialized += Serializer<T>::Serialize(stream, value.data[i]);
             }
+            return serialized;
         }
 
-        static bool Deserialize(DeserializeStream& stream, Vec<T, L>& value)
+        static size_t Deserialize(DeserializeStream& stream, Vec<T, L>& value)
         {
-            if (!TypeIdSerializer<Vec<T, L>>::Deserialize(stream)) {
-                return false;
-            }
-
+            size_t deserialized = 0;
             for (auto i = 0; i < L; i++) {
-                Serializer<T>::Deserialize(stream, value.data[i]);
+                deserialized += Serializer<T>::Deserialize(stream, value.data[i]);
             }
-            return true;
+            return deserialized;
         }
     };
 
diff --git a/Engine/Source/Common/Include/Common/Math/View.h b/Engine/Source/Common/Include/Common/Math/View.h
index 0933049b..92cf2fa1 100644
--- a/Engine/Source/Common/Include/Common/Math/View.h
+++ b/Engine/Source/Common/Include/Common/Math/View.h
@@ -32,25 +32,18 @@ namespace Common {
 namespace Common {
     template <Serializable T>
     struct Serializer<ViewTransform<T>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("Common::ViewTransform")
             + Serializer<T>::typeId;
 
-        static void Serialize(SerializeStream& stream, const ViewTransform<T>& value)
+        static size_t Serialize(SerializeStream& stream, const ViewTransform<T>& value)
         {
-            TypeIdSerializer<ViewTransform<T>>::Serialize(stream);
-
-            Serializer<Transform<T>>::Serialize(stream, value);
+            return Serializer<Transform<T>>::Serialize(stream, value);
         }
 
-        static bool Deserialize(DeserializeStream& stream, ViewTransform<T>& value)
+        static size_t Deserialize(DeserializeStream& stream, ViewTransform<T>& value)
         {
-            if (!TypeIdSerializer<ViewTransform<T>>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<Transform<T>>::Deserialize(stream, value);
-            return true;
+            return Serializer<Transform<T>>::Deserialize(stream, value);
         }
     };
 
diff --git a/Engine/Source/Common/Include/Common/Serialization.h b/Engine/Source/Common/Include/Common/Serialization.h
index 423384b7..540f4eed 100644
--- a/Engine/Source/Common/Include/Common/Serialization.h
+++ b/Engine/Source/Common/Include/Common/Serialization.h
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <cstdint>
 #include <fstream>
 #include <string>
 #include <optional>
@@ -26,6 +27,7 @@ namespace Common {
 
         virtual void Write(const void* data, size_t size) = 0;
         virtual void Seek(int64_t offset) = 0;
+        virtual size_t Loc() = 0;
 
     protected:
         SerializeStream();
@@ -38,6 +40,7 @@ namespace Common {
 
         virtual void Read(void* data, size_t size) = 0;
         virtual void Seek(int64_t offset) = 0;
+        virtual size_t Loc() = 0;
 
     protected:
         DeserializeStream();
@@ -50,6 +53,7 @@ namespace Common {
         ~BinaryFileSerializeStream() override;
         void Write(const void* data, size_t size) override;
         void Seek(int64_t offset) override;
+        size_t Loc() override;
         void Close();
 
     private:
@@ -63,10 +67,12 @@ namespace Common {
         ~BinaryFileDeserializeStream() override;
         void Read(void* data, size_t size) override;
         void Seek(int64_t offset) override;
+        size_t Loc() override;
         void Close();
 
     private:
         std::ifstream file;
+        size_t fileSize;
     };
 
     class ByteSerializeStream final : public SerializeStream {
@@ -76,6 +82,7 @@ namespace Common {
         ~ByteSerializeStream() override;
         void Write(const void* data, size_t size) override;
         void Seek(int64_t offset) override;
+        size_t Loc() override;
 
     private:
         size_t pointer;
@@ -89,6 +96,7 @@ namespace Common {
         ~ByteDeserializeStream() override;
         void Read(void* data, size_t size) override;
         void Seek(int64_t offset) override;
+        size_t Loc() override;
 
     private:
         size_t pointer;
@@ -99,18 +107,14 @@ namespace Common {
     template <typename T> concept Serializable = requires(T inValue, SerializeStream& serializeStream, DeserializeStream& deserializeStream)
     {
         { Serializer<T>::typeId } -> std::convertible_to<uint32_t>;
-        Serializer<T>::Serialize(serializeStream, inValue);
-        Serializer<T>::Deserialize(deserializeStream, inValue);
+        { Serializer<T>::Serialize(serializeStream, inValue) } -> std::convertible_to<size_t>;
+        { Serializer<T>::Deserialize(deserializeStream, inValue) } -> std::convertible_to<size_t>;
     };
 
-    template <Serializable T>
-    struct TypeIdSerializer {
-        static void Serialize(SerializeStream& stream);
-        static bool Deserialize(DeserializeStream& stream);
-    };
+    template <Serializable T> struct FieldSerializer;
 
-    template <typename T> void Serialize(SerializeStream& inStream, const T& inValue);
-    template <typename T> bool Deserialize(DeserializeStream& inStream, T& inValue);
+    template <typename T> size_t Serialize(SerializeStream& inStream, const T& inValue);
+    template <typename T> std::pair<bool, size_t> Deserialize(DeserializeStream& inStream, T& inValue);
 
     template <typename T> struct JsonSerializer {};
     template <typename T> concept JsonSerializable = requires(
@@ -129,58 +133,41 @@ namespace Common {
 #define IMPL_BASIC_TYPE_SERIALIZER(typeName) \
     template <> \
     struct Serializer<typeName> { \
-        static constexpr uint32_t typeId = HashUtils::StrCrc32(#typeName); \
+        static constexpr size_t typeId = HashUtils::StrCrc32(#typeName); \
         \
-        static void Serialize(SerializeStream& stream, const typeName& value) \
+        static size_t Serialize(SerializeStream& stream, const typeName& value) \
         { \
-            TypeIdSerializer<typeName>::Serialize(stream); \
             stream.Write(&value, sizeof(typeName)); \
+            return sizeof(typeName); \
         } \
         \
-        static bool Deserialize(DeserializeStream& stream, typeName& value) \
+        static size_t Deserialize(DeserializeStream& stream, typeName& value) \
         { \
-            if (!TypeIdSerializer<typeName>::Deserialize(stream)) { \
-                return false;\
-            } \
             stream.Read(&value, sizeof(typeName)); \
-            return true; \
+            return sizeof(typeName); \
         } \
     }; \
 
 namespace Common {
-    template <Serializable T>
-    void TypeIdSerializer<T>::Serialize(SerializeStream& stream)
-    {
-        const uint32_t typeId = Serializer<T>::typeId;
-        stream.Write(&typeId, sizeof(uint32_t));
-    }
-
-    template <Serializable T>
-    bool TypeIdSerializer<T>::Deserialize(DeserializeStream& stream)
-    {
-        uint32_t typeId;
-        stream.Read(&typeId, sizeof(uint32_t));
-        return typeId == Serializer<T>::typeId;
-    }
-
     template <typename T>
-    void Serialize(SerializeStream& inStream, const T& inValue)
+    size_t Serialize(SerializeStream& inStream, const T& inValue)
     {
         if constexpr (Serializable<T>) {
-            Serializer<T>::Serialize(inStream, inValue);
+            return FieldSerializer<T>::Serialize(inStream, inValue);
         } else {
             QuickFailWithReason("your type is not support serialization");
+            return 0;
         }
     }
 
     template <typename T>
-    bool Deserialize(DeserializeStream& inStream, T& inValue)
+    std::pair<bool, size_t> Deserialize(DeserializeStream& inStream, T& inValue)
     {
         if constexpr (Serializable<T>) {
-            return Serializer<T>::Deserialize(inStream, inValue);
+            return FieldSerializer<T>::Deserialize(inStream, inValue);
         } else {
             QuickFailWithReason("your type is not support serialization");
-            return false;
+            return { false, 0 };
         }
     }
 
@@ -204,6 +191,45 @@ namespace Common {
         }
     }
 
+    template <Serializable T>
+    struct FieldSerializer {
+        struct Header {
+            size_t typeId;
+            size_t contentSize;
+        };
+
+        static size_t Serialize(SerializeStream& stream, const T& value)
+        {
+            Header header;
+            header.typeId = Serializer<T>::typeId;
+
+            stream.Seek(sizeof(Header));
+            header.contentSize = Serializer<T>::Serialize(stream, value);
+            stream.Seek(-static_cast<int64_t>(sizeof(Header)) - static_cast<int64_t>(header.contentSize));
+            stream.Write(&header, sizeof(Header));
+            stream.Seek(header.contentSize);
+            return sizeof(Header) + header.contentSize;
+        }
+
+        static std::pair<bool, size_t> Deserialize(DeserializeStream& stream, T& value)
+        {
+            Header header {};
+            stream.Read(&header, sizeof(Header));
+
+            if (header.typeId != Serializer<T>::typeId) {
+                stream.Seek(header.contentSize);
+                return { false, sizeof(Header) };
+            }
+
+            size_t deserializedSize = Serializer<T>::Deserialize(stream, value);
+            if (deserializedSize != header.contentSize) {
+                stream.Seek(header.contentSize - deserializedSize);
+                return { false, sizeof(Header) + deserializedSize };
+            }
+            return { true, sizeof(Header) + header.contentSize };
+        }
+    };
+
     IMPL_BASIC_TYPE_SERIALIZER(bool)
     IMPL_BASIC_TYPE_SERIALIZER(int8_t)
     IMPL_BASIC_TYPE_SERIALIZER(uint8_t)
@@ -218,212 +244,199 @@ namespace Common {
 
     template <>
     struct Serializer<std::string> {
-        static constexpr uint32_t typeId = HashUtils::StrCrc32("string");
+        static constexpr size_t typeId = HashUtils::StrCrc32("string");
 
-        static void Serialize(SerializeStream& stream, const std::string& value)
+        static size_t Serialize(SerializeStream& stream, const std::string& value)
         {
-            TypeIdSerializer<std::string>::Serialize(stream);
+            size_t serialized = 0;
 
             const uint64_t size = value.size();
-            Serializer<uint64_t>::Serialize(stream, size);
+            serialized += Serializer<uint64_t>::Serialize(stream, size);
+
             stream.Write(value.data(), value.size());
+            serialized += size;
+            return serialized;
         }
 
-        static bool Deserialize(DeserializeStream& stream, std::string& value)
+        static size_t Deserialize(DeserializeStream& stream, std::string& value)
         {
-            if (!TypeIdSerializer<std::string>::Deserialize(stream)) {
-                return false;
-            }
+            size_t deserialized = 0;
 
             uint64_t size;
-            Serializer<uint64_t>::Deserialize(stream, size);
+            deserialized += Serializer<uint64_t>::Deserialize(stream, size);
+
             value.resize(size);
             stream.Read(value.data(), size);
-            return true;
+            deserialized += size;
+            return deserialized;
         }
     };
 
     template <Serializable T>
     struct Serializer<std::optional<T>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("std::optional")
             + Serializer<T>::typeId;
 
-        static void Serialize(SerializeStream& stream, const std::optional<T>& value)
+        static size_t Serialize(SerializeStream& stream, const std::optional<T>& value)
         {
-            TypeIdSerializer<std::optional<T>>::Serialize(stream);
+            size_t serialized = 0;
 
             const bool hasValue = value.has_value();
-            Serializer<bool>::Serialize(stream, hasValue);
+            serialized += Serializer<bool>::Serialize(stream, hasValue);
 
             if (hasValue) {
-                Serializer<T>::Serialize(stream, value.value());
+                serialized += Serializer<T>::Serialize(stream, value.value());
             }
+            return serialized;
         }
 
-        static bool Deserialize(DeserializeStream& stream, std::optional<T>& value)
+        static size_t Deserialize(DeserializeStream& stream, std::optional<T>& value)
         {
-            if (!TypeIdSerializer<std::optional<T>>::Deserialize(stream)) {
-                return false;
-            }
+            size_t deserialized = 0;
 
             value.reset();
             bool hasValue;
-            Serializer<bool>::Deserialize(stream, hasValue);
+            deserialized += Serializer<bool>::Deserialize(stream, hasValue);
 
             if (hasValue) {
                 T temp;
-                Serializer<T>::Deserialize(stream, temp);
+                deserialized += Serializer<T>::Deserialize(stream, temp);
                 value.emplace(std::move(temp));
             }
-            return true;
+            return deserialized;
         }
     };
 
     template <Serializable K, Serializable V>
     struct Serializer<std::pair<K, V>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("std::pair")
             + Serializer<K>::typeId
             + Serializer<V>::typeId;
 
-        static void Serialize(SerializeStream& stream, const std::pair<K, V>& value)
+        static size_t Serialize(SerializeStream& stream, const std::pair<K, V>& value)
         {
-            TypeIdSerializer<std::pair<K, V>>::Serialize(stream);
-
-            Serializer<K>::Serialize(stream, value.first);
-            Serializer<V>::Serialize(stream, value.second);
+            return Serializer<K>::Serialize(stream, value.first)
+                + Serializer<V>::Serialize(stream, value.second);
         }
 
-        static bool Deserialize(DeserializeStream& stream, std::pair<K, V>& value)
+        static size_t Deserialize(DeserializeStream& stream, std::pair<K, V>& value)
         {
-            if (!TypeIdSerializer<std::pair<K, V>>::Deserialize(stream)) {
-                return false;
-            }
-
-            Serializer<K>::Deserialize(stream, value.first);
-            Serializer<V>::Deserialize(stream, value.second);
-            return true;
+            return Serializer<K>::Deserialize(stream, value.first)
+                + Serializer<V>::Deserialize(stream, value.second);
         }
     };
 
     template <Serializable T>
     struct Serializer<std::vector<T>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("std::vector")
             + Serializer<T>::typeId;
 
-        static void Serialize(SerializeStream& stream, const std::vector<T>& value)
+        static size_t Serialize(SerializeStream& stream, const std::vector<T>& value)
         {
-            TypeIdSerializer<std::vector<T>>::Serialize(stream);
+            size_t serialized = 0;
 
             const uint64_t size = value.size();
-            Serializer<uint64_t>::Serialize(stream, size);
+            serialized += Serializer<uint64_t>::Serialize(stream, size);
 
             for (auto i = 0; i < size; i++) {
-                Serializer<T>::Serialize(stream, value[i]);
+                serialized += Serializer<T>::Serialize(stream, value[i]);
             }
+            return serialized;
         }
 
-        static bool Deserialize(DeserializeStream& stream, std::vector<T>& value)
+        static size_t Deserialize(DeserializeStream& stream, std::vector<T>& value)
         {
-            if (!TypeIdSerializer<std::vector<T>>::Deserialize(stream)) {
-                return false;
-            }
+            size_t deserialized = 0;
 
             value.clear();
-
             uint64_t size;
-            Serializer<uint64_t>::Deserialize(stream, size);
+            deserialized += Serializer<uint64_t>::Deserialize(stream, size);
 
             value.reserve(size);
             for (auto i = 0; i < size; i++) {
                 T element;
-                Serializer<T>::Deserialize(stream, element);
+                deserialized += Serializer<T>::Deserialize(stream, element);
                 value.emplace_back(std::move(element));
             }
-            return true;
+            return deserialized;
         }
     };
 
     template <Serializable T>
     struct Serializer<std::unordered_set<T>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("std::unordered_set")
             + Serializer<T>::typeId;
 
-        static void Serialize(SerializeStream& stream, const std::unordered_set<T>& value)
+        static size_t Serialize(SerializeStream& stream, const std::unordered_set<T>& value)
         {
-            TypeIdSerializer<T>::Serialize(stream);
+            size_t serialized = 0;
 
             const uint64_t size = value.size();
-            Serializer<uint64_t>::Serialize(stream, size);
+            serialized += Serializer<uint64_t>::Serialize(stream, size);
 
             for (const auto& element : value) {
-                Serializer<T>::Serialize(stream, element);
+                serialized += Serializer<T>::Serialize(stream, element);
             }
+            return serialized;
         }
 
-        static bool Deserialize(DeserializeStream& stream, std::unordered_set<T>& value)
+        static size_t Deserialize(DeserializeStream& stream, std::unordered_set<T>& value)
         {
-            if (!TypeIdSerializer<T>::Deserialize(stream)) {
-                return false;
-            }
+            size_t deserialized = 0;
 
             value.clear();
-
             uint64_t size;
-            Serializer<uint64_t>::Deserialize(stream, size);
+            deserialized += Serializer<uint64_t>::Deserialize(stream, size);
 
             value.reserve(size);
             for (auto i = 0; i < size; i++) {
                 T temp;
-                Serializer<T>::Deserialize(stream, temp);
+                deserialized += Serializer<T>::Deserialize(stream, temp);
                 value.emplace(std::move(temp));
             }
-            return true;
+            return deserialized;
         }
     };
 
     template <Serializable K, Serializable V>
     struct Serializer<std::unordered_map<K, V>> {
-        static constexpr uint32_t typeId
+        static constexpr size_t typeId
             = HashUtils::StrCrc32("std::unordered_map")
             + Serializer<K>::typeId
             + Serializer<V>::typeId;
 
-        static void Serialize(SerializeStream& stream, const std::unordered_map<K, V>& value)
+        static size_t Serialize(SerializeStream& stream, const std::unordered_map<K, V>& value)
         {
-            TypeIdSerializer<std::unordered_map<K, V>>::Serialize(stream);
+            size_t serialized = 0;
 
             const uint64_t size = value.size();
-            Serializer<uint64_t>::Serialize(stream, size);
+            serialized += Serializer<uint64_t>::Serialize(stream, size);
 
             for (const auto& pair : value) {
-                Serializer<K>::Serialize(stream, pair.first);
-                Serializer<V>::Serialize(stream, pair.second);
+                serialized += Serializer<std::pair<K, V>>::Serialize(stream, pair);
             }
+            return serialized;
         }
 
-        static bool Deserialize(DeserializeStream& stream, std::unordered_map<K, V>& value)
+        static size_t Deserialize(DeserializeStream& stream, std::unordered_map<K, V>& value)
         {
-            if (!TypeIdSerializer<std::unordered_map<K, V>>::Deserialize(stream)) {
-                return false;
-            }
+            size_t deserialized = 0;
 
             value.clear();
-
             uint64_t size;
-            Serializer<uint64_t>::Deserialize(stream, size);
+            deserialized += Serializer<uint64_t>::Deserialize(stream, size);
 
             value.reserve(size);
             for (auto i = 0; i < size; i++) {
                 std::pair<K, V> pair;
-                Serializer<K>::Deserialize(stream, pair.first);
-                Serializer<V>::Deserialize(stream, pair.second);
+                deserialized += Serializer<std::pair<K, V>>::Deserialize(stream, pair);
                 value.emplace(std::move(pair));
             }
-            return true;
+            return deserialized;
         }
     };
 
diff --git a/Engine/Source/Common/Src/Serialization.cpp b/Engine/Source/Common/Src/Serialization.cpp
index 74eed087..9819759e 100644
--- a/Engine/Source/Common/Src/Serialization.cpp
+++ b/Engine/Source/Common/Src/Serialization.cpp
@@ -39,6 +39,11 @@ namespace Common {
         file.seekp(offset, std::ios::cur);
     }
 
+    size_t BinaryFileSerializeStream::Loc()
+    {
+        return file.tellp();
+    }
+
     void BinaryFileSerializeStream::Close()
     {
         if (!file.is_open()) {
@@ -54,6 +59,9 @@ namespace Common {
     BinaryFileDeserializeStream::BinaryFileDeserializeStream(const std::string& inFileName)
         : file(inFileName, std::ios::binary)
     {
+        file.seekg(0, std::ios::end);
+        fileSize = file.tellg();
+        file.seekg(0, std::ios::beg);
     }
 
     BinaryFileDeserializeStream::~BinaryFileDeserializeStream()
@@ -63,6 +71,7 @@ namespace Common {
 
     void BinaryFileDeserializeStream::Read(void* data, const size_t size)
     {
+        Assert(static_cast<size_t>(file.tellg()) + size <= fileSize);
         file.read(static_cast<char*>(data), static_cast<std::streamsize>(size));
     }
 
@@ -71,6 +80,11 @@ namespace Common {
         file.seekg(offset, std::ios::cur);
     }
 
+    size_t BinaryFileDeserializeStream::Loc()
+    {
+        return file.tellg();
+    }
+
     void BinaryFileDeserializeStream::Close()
     {
         if (!file.is_open()) {
@@ -110,6 +124,11 @@ namespace Common {
         pointer += offset;
     }
 
+    size_t ByteSerializeStream::Loc()
+    {
+        return pointer;
+    }
+
     ByteDeserializeStream::ByteDeserializeStream(const std::vector<uint8_t>& inBytes, const size_t pointerBegin)
         : pointer(pointerBegin)
         , bytes(inBytes)
@@ -131,4 +150,9 @@ namespace Common {
     {
         pointer += offset;
     }
+
+    size_t ByteDeserializeStream::Loc()
+    {
+        return pointer;
+    }
 }
diff --git a/Engine/Source/Core/Include/Core/Uri.h b/Engine/Source/Core/Include/Core/Uri.h
index 1e67a3fa..9cee5daf 100644
--- a/Engine/Source/Core/Include/Core/Uri.h
+++ b/Engine/Source/Core/Include/Core/Uri.h
@@ -65,25 +65,19 @@ namespace std { // NOLINT
 namespace Common { // NOLINT
     template <>
     struct Serializer<Core::Uri> {
-        static constexpr uint32_t typeId = HashUtils::StrCrc32("Core::Uri");
+        static constexpr size_t typeId = HashUtils::StrCrc32("Core::Uri");
 
-        static void Serialize(SerializeStream& stream, const Core::Uri& value)
+        static size_t Serialize(SerializeStream& stream, const Core::Uri& value)
         {
-            TypeIdSerializer<std::string>::Serialize(stream);
-
-            Serializer<std::string>::Serialize(stream, value.Str());
+            return Serializer<std::string>::Serialize(stream, value.Str());
         }
 
-        static bool Deserialize(DeserializeStream& stream, Core::Uri& value)
+        static size_t Deserialize(DeserializeStream& stream, Core::Uri& value)
         {
-            if (!TypeIdSerializer<std::string>::Deserialize(stream)) {
-                return false;
-            }
-
             std::string str;
-            Serializer<std::string>::Deserialize(stream, str);
+            const auto deserialized = Serializer<std::string>::Deserialize(stream, str);
             value = str;
-            return true;
+            return deserialized;
         }
     };
 }
diff --git a/Engine/Source/Mirror/Include/Mirror/Mirror.h b/Engine/Source/Mirror/Include/Mirror/Mirror.h
index 92b2085b..ce06cea9 100644
--- a/Engine/Source/Mirror/Include/Mirror/Mirror.h
+++ b/Engine/Source/Mirror/Include/Mirror/Mirror.h
@@ -91,8 +91,8 @@ namespace Mirror {
         using GetPtrFunc = Any(void*);
         using GetConstPtrFunc = Any(const void*);
         using DerefFunc = Any(const void*);
-        using SerializeFunc = void(const void*, Common::SerializeStream&);
-        using DeserializeFunc = bool(void*, Common::DeserializeStream&);
+        using SerializeFunc = size_t(const void*, Common::SerializeStream&);
+        using DeserializeFunc = std::pair<bool, size_t>(void*, Common::DeserializeStream&);
         using JsonSerializeFunc = void(const void*, rapidjson::Value&, rapidjson::Document::AllocatorType&);
         using JsonDeserializeFunc = void(void*, const rapidjson::Value&);
         using ToStringFunc = std::string(const void*);
@@ -111,8 +111,8 @@ namespace Mirror {
         template <typename T> static Any GetPtr(void* inThis);
         template <typename T> static Any GetConstPtr(const void* inThis);
         template <typename T> static Any Deref(const void* inThis);
-        template <typename T> static void Serialize(const void* inThis, Common::SerializeStream& inStream);
-        template <typename T> static bool Deserialize(void* inThis, Common::DeserializeStream& inStream);
+        template <typename T> static size_t Serialize(const void* inThis, Common::SerializeStream& inStream);
+        template <typename T> static std::pair<bool, size_t> Deserialize(void* inThis, Common::DeserializeStream& inStream);
         template <typename T> static void JsonSerialize(const void* inThis, rapidjson::Value& outJsonValue, rapidjson::Document::AllocatorType& inAllocator);
         template <typename T> static void JsonDeserialize(void* inThis, const rapidjson::Value& inJsonValue);
         template <typename T> static std::string ToString(const void* inThis);
@@ -222,9 +222,9 @@ namespace Mirror {
         Mirror::TypeId TypeId() const;
         void Reset();
         bool Empty() const;
-        void Serialize(Common::SerializeStream& inStream) const;
-        bool Deserialize(Common::DeserializeStream& inStream);
-        bool Deserialize(Common::DeserializeStream& inStream) const;
+        size_t Serialize(Common::SerializeStream& inStream) const;
+        std::pair<bool, size_t> Deserialize(Common::DeserializeStream& inStream);
+        std::pair<bool, size_t> Deserialize(Common::DeserializeStream& inStream) const;
         void JsonSerialize(rapidjson::Value& outJsonValue, rapidjson::Document::AllocatorType& inAllocator) const;
         void JsonDeserialize(const rapidjson::Value& inJsonValue);
         void JsonDeserialize(const rapidjson::Value& inJsonValue) const;
@@ -768,8 +768,8 @@ namespace Mirror::Internal {
     {
         using RawType = std::remove_cvref_t<T>;
         static_assert(
-            !std::is_same_v<RawType, Any> && !std::is_same_v<RawType, Any*> && !std::is_same_v<RawType, const Any*>,
-            "static version reflection method do no support use Any/Any*/const Any* as argument, please check you arguments");
+            !std::is_same_v<RawType, Any> && !std::is_same_v<RawType, Any*> && !std::is_same_v<RawType, const Any*> && !std::is_same_v<RawType, Argument>,
+            "static version reflection method do no support use Any/Any*/const Any*/Argument as argument, please check you arguments");
     }
 
     template <typename T>
@@ -805,116 +805,125 @@ namespace Mirror::Internal {
 namespace Common { // NOLINT
     template <Mirror::MetaClass T>
     struct Serializer<T> {
-        static constexpr uint32_t typeId = HashUtils::StrCrc32("_MetaObject");
-
-        // TODO need process serialize failed
-        static void SerializeDyn(SerializeStream& stream, const Mirror::Class& clazz, const Mirror::Argument& obj)
+        static constexpr size_t typeId = HashUtils::StrCrc32("_MetaObject");
+
+        // struct
+        // std::string className                  : classNameSize
+        // size_t baseContentSize                 : sizeof(size_t)
+        // void* baseContent                      : baseContentSize
+        // size_t memberVariableCount             : sizeof(size_t)
+        // size_t[] memberVariableContentEnds     : sizeof(size_t) * memberVariableCount
+        // void*[] memberVariableContent          : memberVariablesContentSize
+        //     |- std::string memberVariableName  : memberVariableNameSize
+        //     |- bool sameAsDefaultObject        : sizeof(bool)
+        //     |- void* memberVariableContent     : memberVariableEnd - memberVariableLastEnd
+
+        static size_t SerializeDyn(SerializeStream& stream, const Mirror::Class& clazz, const Mirror::Argument& obj)
         {
-            if (const auto* baseClass = clazz.GetBaseClass();
-                baseClass != nullptr) {
-                SerializeDyn(stream, *baseClass, obj);
-            }
-
+            const auto& className = clazz.GetName();
+            const auto* baseClass = clazz.GetBaseClass();
+            const auto& memberVariables = clazz.GetMemberVariables();
             const auto defaultObject = clazz.GetDefaultObject();
-            AssertWithReason(!defaultObject.Empty(), "do you forget add default constructor to EClass() which you want to serialize ?");
 
-            const auto& name = clazz.GetName();
-            const auto& memberVariables = clazz.GetMemberVariables();
+            const auto classNameSize = Serializer<std::string>::Serialize(stream, className);
 
-            const auto memberVariablesNum = memberVariables.size();
-            Serializer<std::string>::Serialize(stream, name);
-            Serializer<uint64_t>::Serialize(stream, memberVariablesNum);
+            uint64_t baseClassContentSize = 0;
+            stream.Seek(sizeof(uint64_t));
+            if (baseClass != nullptr) {
+                baseClassContentSize = SerializeDyn(stream, *baseClass, obj);
+            }
 
-            for (const auto& [id, memberVariable] : memberVariables) {
-                if (memberVariable.IsTransient()) {
-                    continue;
-                }
+            stream.Seek(-static_cast<int64_t>(baseClassContentSize) - static_cast<int64_t>(sizeof(uint64_t)));
+            Serializer<uint64_t>::Serialize(stream, baseClassContentSize);
+            stream.Seek(static_cast<int64_t>(baseClassContentSize));
 
-                Serializer<std::string>::Serialize(stream, id.name);
+            const uint64_t memberVariableCount = memberVariables.size();
+            std::vector<uint64_t> memberVariableContentEnds;
+            memberVariableContentEnds.reserve(memberVariableCount);
 
-                const bool sameWithDefaultObject = memberVariable.GetDyn(obj) == memberVariable.GetDyn(defaultObject);
-                Serializer<bool>::Serialize(stream, sameWithDefaultObject);
+            stream.Seek(static_cast<int64_t>(sizeof(uint64_t) * (memberVariableCount + 1)));
+            uint64_t memberVariableContentSize = 0;
+            for (const auto& [id, memberVariable] : memberVariables) {
+                const bool sameAsDefaultObject = defaultObject.Empty() ? false : memberVariable.GetDyn(obj) == memberVariable.GetDyn(defaultObject);
 
-                if (sameWithDefaultObject) {
-                    Serializer<uint32_t>::Serialize(stream, 0);
-                } else {
-                    Serializer<uint32_t>::Serialize(stream, memberVariable.SizeOf());
-                    memberVariable.GetDyn(obj).Serialize(stream);
+                memberVariableContentSize += Serializer<std::string>::Serialize(stream, memberVariable.GetName());
+                memberVariableContentSize += Serializer<bool>::Serialize(stream, sameAsDefaultObject);
+                if (!sameAsDefaultObject) {
+                    memberVariableContentSize += memberVariable.GetDyn(obj).Serialize(stream);
                 }
+                memberVariableContentEnds.emplace_back(memberVariableContentSize);
             }
 
-            if (clazz.HasMemberFunction("OnSerialized")) {
-                (void) clazz.GetMemberFunction("OnSerialized").InvokeDyn(obj, {});
+            stream.Seek(-static_cast<int64_t>(memberVariableContentSize) - static_cast<int64_t>(sizeof(uint64_t) * (memberVariableCount + 1)));
+            Serializer<uint64_t>::Serialize(stream, memberVariableCount);
+            for (const auto& end : memberVariableContentEnds) {
+                Serializer<uint64_t>::Serialize(stream, end);
             }
+            stream.Seek(static_cast<int64_t>(memberVariableContentSize));
+            return classNameSize + baseClassContentSize + sizeof(uint64_t) * (memberVariableCount + 2) + memberVariableContentSize; // NOLINT
         }
 
-        static bool DeserializeDyn(DeserializeStream& stream, const Mirror::Class& clazz, const Mirror::Argument& obj)
+        static size_t DeserializeDyn(DeserializeStream& stream, const Mirror::Class& clazz, const Mirror::Argument& obj)
         {
-            if (const auto* baseClass = clazz.GetBaseClass();
-                baseClass != nullptr) {
-                DeserializeDyn(stream, *baseClass, obj);
-            }
-
+            const auto& className = clazz.GetName();
+            const auto* baseClass = clazz.GetBaseClass();
+            const auto& memberVariables = clazz.GetMemberVariables();
             const auto defaultObject = clazz.GetDefaultObject();
-            AssertWithReason(!defaultObject.Empty(), "do you forget add default constructor to EClass() which you want to serialize ?");
-
-            std::string className;
-            Serializer<std::string>::Deserialize(stream, className);
 
-            uint64_t memberVariableSize;
-            Serializer<uint64_t>::Deserialize(stream, memberVariableSize);
+            std::string name;
+            const auto nameSize = Serializer<std::string>::Deserialize(stream, name);
 
-            uint32_t failedCount = 0;
-            const auto& memberVariables = clazz.GetMemberVariables();
-            for (auto i = 0; i < memberVariableSize; i++) {
-                std::string varName;
-                Serializer<std::string>::Deserialize(stream, varName);
+            uint64_t aspectBaseClassContentSize = 0;
+            Serializer<uint64_t>::Deserialize(stream, aspectBaseClassContentSize);
+            if (aspectBaseClassContentSize != 0 && baseClass != nullptr) {
+                const auto actualBaseClassContentSize = DeserializeDyn(stream, *baseClass, obj);
+                stream.Seek(static_cast<int64_t>(aspectBaseClassContentSize) - static_cast<int64_t>(actualBaseClassContentSize));
+            }
 
-                auto iter = memberVariables.find(varName);
-                if (iter == memberVariables.end()) {
-                    failedCount++;
-                    continue;
-                }
+            uint64_t memberVariableCount = 0;
+            Serializer<uint64_t>::Deserialize(stream, memberVariableCount);
 
-                const auto& memberVariable = iter->second;
-                if (memberVariable.IsTransient()) {
-                    continue;
-                }
+            std::vector<uint64_t> memberVariableEnds;
+            memberVariableEnds.resize(memberVariableCount);
+            for (auto& offset : memberVariableEnds) {
+                Serializer<uint64_t>::Deserialize(stream, offset);
+            }
 
-                bool restoreAsDefaultObject = true;
-                Serializer<bool>::Deserialize(stream, restoreAsDefaultObject);
+            uint64_t memberVariableContentCur = 0;
+            for (const auto& end : memberVariableEnds) {
+                std::string memberVariableName;
+                memberVariableContentCur += Serializer<std::string>::Deserialize(stream, memberVariableName);
 
-                uint32_t memorySize = 0;
-                Serializer<uint32_t>::Deserialize(stream, memorySize);
-                if (memorySize == 0 || memorySize != memberVariable.SizeOf()) {
-                    failedCount++;
-                    restoreAsDefaultObject = true;
+                if (!clazz.HasMemberVariable(memberVariableName)) {
+                    stream.Seek(static_cast<int64_t>(end) - static_cast<int64_t>(memberVariableContentCur));
+                    memberVariableContentCur = end;
+                    continue;
                 }
-
-                if (restoreAsDefaultObject) {
-                    memberVariable.SetDyn(obj, memberVariable.GetDyn(defaultObject));
-                } else {
-                    memberVariable.GetDyn(obj).Deserialize(stream);
+                const auto& memberVariable = clazz.GetMemberVariable(memberVariableName);
+
+                bool sameAsDefaultObject = false;
+                memberVariableContentCur += Serializer<bool>::Deserialize(stream, sameAsDefaultObject);
+                if (sameAsDefaultObject) {
+                    if (!defaultObject.Empty()) {
+                        memberVariable.SetDyn(obj, memberVariable.GetDyn(obj));
+                    }
+                    continue;
                 }
-            }
 
-            if (clazz.HasMemberFunction("OnDeserialize")) {
-                (void) clazz.GetMemberFunction("OnDeserialize").InvokeDyn(obj, {});
+                memberVariableContentCur += memberVariable.GetDyn(obj).Deserialize(stream).second;
+                stream.Seek(static_cast<int64_t>(end) - static_cast<int64_t>(memberVariableContentCur));
+                memberVariableContentCur = end;
             }
-            return failedCount == 0;
+            return nameSize + aspectBaseClassContentSize + sizeof(uint64_t) * (memberVariableCount + 2) + memberVariableContentCur;
         }
 
-        static void Serialize(SerializeStream& stream, const T& value)
+        static size_t Serialize(SerializeStream& stream, const T& value)
         {
-            TypeIdSerializer<T>::Serialize(stream);
-            SerializeDyn(stream, Mirror::Class::Get<T>(), Mirror::Internal::ForwardAsArgument(value));
+            return SerializeDyn(stream, Mirror::Class::Get<T>(), Mirror::Internal::ForwardAsArgument(value));
         }
 
-        static bool Deserialize(DeserializeStream& stream, T& value)
+        static size_t Deserialize(DeserializeStream& stream, T& value)
         {
-            if (!TypeIdSerializer<T>::Deserialize(stream)) {
-                return false;
-            }
             return DeserializeDyn(stream, Mirror::Class::Get<T>(), Mirror::Internal::ForwardAsArgument(value));
         }
     };
@@ -1094,13 +1103,13 @@ namespace Mirror {
     }
 
     template <typename T>
-    void AnyRtti::Serialize(const void* inThis, Common::SerializeStream& inStream)
+    size_t AnyRtti::Serialize(const void* inThis, Common::SerializeStream& inStream)
     {
-        Common::Serialize<T>(inStream, *static_cast<const T*>(inThis));
+        return Common::Serialize<T>(inStream, *static_cast<const T*>(inThis));
     }
 
     template <typename T>
-    bool AnyRtti::Deserialize(void* inThis, Common::DeserializeStream& inStream)
+    std::pair<bool, size_t> AnyRtti::Deserialize(void* inThis, Common::DeserializeStream& inStream)
     {
         return Common::Deserialize<T>(inStream, *static_cast<T*>(inThis));
     }
diff --git a/Engine/Source/Mirror/Src/Mirror.cpp b/Engine/Source/Mirror/Src/Mirror.cpp
index 52822768..117d880c 100644
--- a/Engine/Source/Mirror/Src/Mirror.cpp
+++ b/Engine/Source/Mirror/Src/Mirror.cpp
@@ -394,19 +394,19 @@ namespace Mirror {
         return rtti == nullptr;
     }
 
-    void Any::Serialize(Common::SerializeStream& inStream) const
+    size_t Any::Serialize(Common::SerializeStream& inStream) const
     {
         Assert(rtti != nullptr);
-        rtti->serialize(Data(), inStream);
+        return rtti->serialize(Data(), inStream);
     }
 
-    bool Any::Deserialize(Common::DeserializeStream& inStream)
+    std::pair<bool, size_t> Any::Deserialize(Common::DeserializeStream& inStream)
     {
         Assert(rtti != nullptr && !IsConstRef());
         return rtti->deserialize(Data(), inStream);
     }
 
-    bool Any::Deserialize(Common::DeserializeStream& inStream) const
+    std::pair<bool, size_t> Any::Deserialize(Common::DeserializeStream& inStream) const
     {
         Assert(rtti != nullptr && IsNonConstRef());
         return rtti->deserialize(Data(), inStream);
diff --git a/Engine/Source/Mirror/Test/SerializationTest.cpp b/Engine/Source/Mirror/Test/SerializationTest.cpp
index e8646694..1c2e24e0 100644
--- a/Engine/Source/Mirror/Test/SerializationTest.cpp
+++ b/Engine/Source/Mirror/Test/SerializationTest.cpp
@@ -13,7 +13,7 @@ int ga = 0;
 float gb = 0.0f;
 std::string gc;
 
-TEST(SerializationTest, VariableFileSerializationTest)
+TEST(SerializationTest, VariableFileTest)
 {
     static std::filesystem::path fileName = "../Test/Generated/Mirror/SerializationTest.VariableFileSerializationTest.bin";
     std::filesystem::create_directories(fileName.parent_path());
@@ -48,7 +48,7 @@ TEST(SerializationTest, VariableFileSerializationTest)
     }
 }
 
-TEST(SerializationTest, ClassFileSerializationTest)
+TEST(SerializationTest, ClassFileTest)
 {
     static std::filesystem::path fileName = "../Test/Generated/Mirror/SerializationTest.ClassFileSerializationTest.bin";
     std::filesystem::create_directories(fileName.parent_path());
@@ -75,7 +75,7 @@ TEST(SerializationTest, ClassFileSerializationTest)
     }
 }
 
-TEST(SerializationTest, ContainerFileSerializationTest)
+TEST(SerializationTest, ContainerFileTest)
 {
     static std::filesystem::path fileName = "../Test/Generated/Mirror/SerializationTest.ContainerFileSerializationTest.bin";
     std::filesystem::create_directories(fileName.parent_path());
@@ -124,7 +124,22 @@ TEST(SerializationTest, ContainerFileSerializationTest)
     }
 }
 
-TEST(SerializationTest, MetaObjectTypeSerializationTest)
+TEST(SerializationTest, MetaObjectTypeTest)
+{
+    // TODO
+}
+
+TEST(SerializationTest, MetaObjectSameAsDefaultObjectTest)
+{
+    // TODO
+}
+
+TEST(SerializationTest, MetaObjectWithBaseClassTest)
+{
+    // TODO
+}
+
+TEST(SerializationTest, MetaObjectUpgradeTest)
 {
     // TODO
 }
diff --git a/Engine/Source/Runtime/Include/Runtime/Asset.h b/Engine/Source/Runtime/Include/Runtime/Asset.h
index fa0114b5..1e33c395 100644
--- a/Engine/Source/Runtime/Include/Runtime/Asset.h
+++ b/Engine/Source/Runtime/Include/Runtime/Asset.h
@@ -410,47 +410,37 @@ namespace Runtime {
 namespace Common {
     template <DerivedFrom<Runtime::Asset> A>
     struct Serializer<Runtime::AssetRef<A>> {
-        static constexpr uint32_t typeId = Common::HashUtils::StrCrc32("Runtime::AssetRef");
+        static constexpr size_t typeId = Common::HashUtils::StrCrc32("Runtime::AssetRef");
 
-        static void Serialize(SerializeStream& stream, const Runtime::AssetRef<A>& value)
+        static size_t Serialize(SerializeStream& stream, const Runtime::AssetRef<A>& value)
         {
-            TypeIdSerializer<Runtime::AssetRef<A>>::Serialize(stream);
-            Serializer<Core::Uri>::Serialize(stream, value);
+            return Serializer<Core::Uri>::Serialize(stream, value);
         }
 
-        static bool Deserialize(DeserializeStream& stream, Runtime::AssetRef<A>& value)
+        static size_t Deserialize(DeserializeStream& stream, Runtime::AssetRef<A>& value)
         {
-            if (!TypeIdSerializer<Runtime::AssetRef<A>>::Deserialize(stream)) {
-                return false;
-            }
-
             Core::Uri uri;
-            Serializer<Core::Uri>::Deserialize(stream, uri);
+            const auto deserialized = Serializer<Core::Uri>::Deserialize(stream, uri);
             value = Runtime::AssetManager::Get().SyncLoad<A>(uri, uri);
-            return true;
+            return deserialized;
         }
     };
 
     template <DerivedFrom<Runtime::Asset> A>
     struct Serializer<Runtime::SoftAssetRef<A>> {
-        static constexpr uint32_t typeId = Common::HashUtils::StrCrc32("Runtime::SoftAssetRef");
+        static constexpr size_t typeId = Common::HashUtils::StrCrc32("Runtime::SoftAssetRef");
 
-        static void Serialize(SerializeStream& stream, const Runtime::SoftAssetRef<A>& value)
+        static size_t Serialize(SerializeStream& stream, const Runtime::SoftAssetRef<A>& value)
         {
-            TypeIdSerializer<Runtime::AssetRef<A>>::Serialize(stream);
-            Serializer<Core::Uri>::Serialize(stream, value);
+            return Serializer<Core::Uri>::Serialize(stream, value);
         }
 
-        static bool Deserialize(DeserializeStream& stream, Runtime::SoftAssetRef<A>& value)
+        static size_t Deserialize(DeserializeStream& stream, Runtime::SoftAssetRef<A>& value)
         {
-            if (!TypeIdSerializer<Runtime::AssetRef<A>>::Deserialize(stream)) {
-                return false;
-            }
-
             Core::Uri uri;
-            Serializer<Core::Uri>::Deserialize(stream, uri);
+            const auto deserialized = Serializer<Core::Uri>::Deserialize(stream, uri);
             value = uri;
-            return true;
+            return deserialized;
         }
     };
 }