Add serde array workaround

crates/bevy_math/src/primitives/dim2.rs

@@ -241,9 +241,10 @@ impl Segment2d {
 ///
 /// For a version without generics: [`BoxedPolyline2d`]
 #[derive(Clone, Debug, PartialEq)]
-// #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 pub struct Polyline2d<const N: usize> {
     /// The vertices of the polyline
+    #[serde(with = "super::serde::array")]
     pub vertices: [Vec2; N],
 }
 impl<const N: usize> Primitive2d for Polyline2d<N> {}
@@ -404,9 +405,10 @@ impl Rectangle {
 ///
 /// For a version without generics: [`BoxedPolygon`]
 #[derive(Clone, Debug, PartialEq)]
-// #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 pub struct Polygon<const N: usize> {
     /// The vertices of the `Polygon`
+    #[serde(with = "super::serde::array")]
     pub vertices: [Vec2; N],
 }
 impl<const N: usize> Primitive2d for Polygon<N> {}

crates/bevy_math/src/primitives/dim3.rs

@@ -199,9 +199,10 @@ impl Segment3d {
 ///
 /// For a version without generics: [`BoxedPolyline3d`]
 #[derive(Clone, Debug, PartialEq)]
-// #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 pub struct Polyline3d<const N: usize> {
     /// The vertices of the polyline
+    #[serde(with = "super::serde::array")]
     pub vertices: [Vec3; N],
 }
 impl<const N: usize> Primitive3d for Polyline3d<N> {}

crates/bevy_math/src/primitives/mod.rs

@@ -6,6 +6,8 @@ mod dim2;
 pub use dim2::*;
 mod dim3;
 pub use dim3::*;
+#[cfg(feature = "serialize")]
+mod serde;
 
 /// A marker trait for 2D primitives
 pub trait Primitive2d {}

crates/bevy_math/src/primitives/serde.rs

@@ -0,0 +1,63 @@
+//! This module defines serialization/deserialization for const generic arrays.
+//! Unlike serde's default behavior, it supports arbitrarily large arrays.
+//! The code is based on this github comment:
+//! <https://github.com/serde-rs/serde/issues/1937#issuecomment-812137971>
+
+pub(crate) mod array {
+    use serde::{
+        de::{SeqAccess, Visitor},
+        ser::SerializeTuple,
+        Deserialize, Deserializer, Serialize, Serializer,
+    };
+    use std::marker::PhantomData;
+
+    pub fn serialize<S: Serializer, T: Serialize, const N: usize>(
+        data: &[T; N],
+        ser: S,
+    ) -> Result<S::Ok, S::Error> {
+        let mut s = ser.serialize_tuple(N)?;
+        for item in data {
+            s.serialize_element(item)?;
+        }
+        s.end()
+    }
+
+    struct GenericArrayVisitor<T, const N: usize>(PhantomData<T>);
+
+    impl<'de, T, const N: usize> Visitor<'de> for GenericArrayVisitor<T, N>
+    where
+        T: Deserialize<'de>,
+    {
+        type Value = [T; N];
+
+        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+            formatter.write_str(&format!("an array of length {}", N))
+        }
+
+        #[inline]
+        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+        where
+            A: SeqAccess<'de>,
+        {
+            let mut data = Vec::with_capacity(N);
+            for _ in 0..N {
+                match (seq.next_element())? {
+                    Some(val) => data.push(val),
+                    None => return Err(serde::de::Error::invalid_length(N, &self)),
+                }
+            }
+            match data.try_into() {
+                Ok(arr) => Ok(arr),
+                Err(_) => unreachable!(),
+            }
+        }
+    }
+
+    pub fn deserialize<'de, D, T, const N: usize>(deserializer: D) -> Result<[T; N], D::Error>
+    where
+        D: Deserializer<'de>,
+        T: Deserialize<'de>,
+    {
+        deserializer.deserialize_tuple(N, GenericArrayVisitor::<T, N>(PhantomData))
+    }
+}