glam_det 2.0.0

// Copyright (C) 2020-2025 glam-det authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

macro_rules! impl_serde_vec2_wide {
    ($t:ty, $vec2:ident) => {
        impl_serde_vec2_wide!($t, $vec2, test_vec2_serde);
    };
    ($t:ty, $vec2:ident, $test_name:ident) => {
        impl_serde_vec2_wide!($t, $vec2, $test_name, new);
    };
    ($t:ty, $vec2:ident, $test_name:ident, $new_fn:ident) => {
        impl Serialize for $vec2 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                let mut state = serializer.serialize_tuple_struct(stringify!($vec2), 2)?;
                state.serialize_field(&self.x)?;
                state.serialize_field(&self.y)?;
                state.end()
            }
        }

        impl<'de> Deserialize<'de> for $vec2 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                struct Vec2Visitor;

                impl<'de> Visitor<'de> for Vec2Visitor {
                    type Value = $vec2;

                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
                        formatter.write_str(concat!("struct ", stringify!($vec2)))
                    }

                    fn visit_seq<V>(self, mut seq: V) -> Result<$vec2, V::Error>
                    where
                        V: SeqAccess<'de>,
                    {
                        let x = seq
                            .next_element()?
                            .ok_or_else(|| de::Error::invalid_length(0, &self))?;
                        let y = seq
                            .next_element()?
                            .ok_or_else(|| de::Error::invalid_length(1, &self))?;
                        Ok($vec2::$new_fn(x, y))
                    }
                }

                deserializer.deserialize_tuple_struct(stringify!($vec2), 2, Vec2Visitor)
            }
        }
    };
}
#[cfg(test)]
macro_rules! impl_serde_vec2_wide_test {
    ($t:ty, $vec2:ident) => {
        impl_serde_vec2_wide_test!($t, $vec2, test_vec2_serde);
    };
    ($t:ty, $vec2:ident, $test_name:ident) => {
        impl_serde_vec2_wide_test!($t, $vec2, $test_name, new);
    };
    ($t:ty, $vec2:ident, $test_name:ident, $new_fn:ident) => {
        #[test]
        fn $test_name() {
            let a = $vec2::$new_fn(ONE, TWO);
            let serialized = serde_json::to_string(&a).unwrap();
            assert_eq!(SX2, serialized);
            let deserialized = serde_json::from_str(&serialized).unwrap();
            assert_eq!(a, deserialized);
            let deserialized = serde_json::from_str::<$vec2>(SX0);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$vec2>(SX1);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$vec2>(SX3);
            assert!(deserialized.is_err());
        }
    };
}

macro_rules! impl_serde_vec3_wide {
    ($t:ty, $vec3:ident) => {
        impl_serde_vec3_wide!($t, $vec3, test_vec3_serde);
    };
    ($t:ty, $vec3:ident, $test_name:ident) => {
        impl_serde_vec3_wide!($t, $vec3, $test_name, new);
    };
    ($t:ty, $vec3:ident, $test_name:ident, $new_fn:ident) => {
        impl Serialize for $vec3 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                let mut state = serializer.serialize_tuple_struct(stringify!($vec3), 3)?;
                state.serialize_field(&self.x)?;
                state.serialize_field(&self.y)?;
                state.serialize_field(&self.z)?;
                state.end()
            }
        }

        impl<'de> Deserialize<'de> for $vec3 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                struct Vec3Visitor;

                impl<'de> Visitor<'de> for Vec3Visitor {
                    type Value = $vec3;

                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
                        formatter.write_str(concat!("struct ", stringify!($vec3)))
                    }

                    fn visit_seq<V>(self, mut seq: V) -> Result<$vec3, V::Error>
                    where
                        V: SeqAccess<'de>,
                    {
                        let x = seq
                            .next_element()?
                            .ok_or_else(|| de::Error::invalid_length(0, &self))?;
                        let y = seq
                            .next_element()?
                            .ok_or_else(|| de::Error::invalid_length(1, &self))?;
                        let z = seq
                            .next_element()?
                            .ok_or_else(|| de::Error::invalid_length(2, &self))?;
                        Ok($vec3::$new_fn(x, y, z))
                    }
                }

                deserializer.deserialize_tuple_struct(stringify!($vec3), 3, Vec3Visitor)
            }
        }
    };
}

#[cfg(test)]
macro_rules! impl_serde_vec3_wide_test {
    ($t:ty, $vec3:ident) => {
        impl_serde_vec3_wide_test!($t, $vec3, test_vec3_serde);
    };
    ($t:ty, $vec3:ident, $test_name:ident) => {
        impl_serde_vec3_wide_test!($t, $vec3, $test_name, new);
    };
    ($t:ty, $vec3:ident, $test_name:ident, $new_fn:ident) => {
        #[test]
        fn $test_name() {
            let a = $vec3::$new_fn(ONE, TWO, THREE);
            let serialized = serde_json::to_string(&a).unwrap();
            assert_eq!(SX3, serialized);
            let deserialized = serde_json::from_str(&serialized).unwrap();
            assert_eq!(a, deserialized);
            let deserialized = serde_json::from_str::<$vec3>(SX0);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$vec3>(SX1);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$vec3>(SX2);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$vec3>(SX4);
            assert!(deserialized.is_err());
        }
    };
}

macro_rules! impl_serde_vec4_wide {
    ($t:ty, $vec4:ident) => {
        impl_serde_vec4_wide!($t, $vec4, test_vec4_serde);
    };
    ($t:ty, $vec4:ident, $test_name:ident) => {
        impl_serde_vec4_wide!($t, $vec4, $test_name, new);
    };
    ($t:ty, $vec4:ident, $test_name:ident, $new_fn:ident) => {
        impl Serialize for $vec4 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                let mut state = serializer.serialize_tuple_struct(stringify!($vec4), 4)?;
                state.serialize_field(&self.x)?;
                state.serialize_field(&self.y)?;
                state.serialize_field(&self.z)?;
                state.serialize_field(&self.w)?;
                state.end()
            }
        }

        impl<'de> Deserialize<'de> for $vec4 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                struct Vec4Visitor;

                impl<'de> Visitor<'de> for Vec4Visitor {
                    type Value = $vec4;

                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
                        formatter.write_str(concat!("struct ", stringify!($vec4)))
                    }

                    fn visit_seq<V>(self, mut seq: V) -> Result<$vec4, V::Error>
                    where
                        V: SeqAccess<'de>,
                    {
                        let x = seq
                            .next_element()?
                            .ok_or_else(|| de::Error::invalid_length(0, &self))?;
                        let y = seq
                            .next_element()?
                            .ok_or_else(|| de::Error::invalid_length(1, &self))?;
                        let z = seq
                            .next_element()?
                            .ok_or_else(|| de::Error::invalid_length(2, &self))?;
                        let w = seq
                            .next_element()?
                            .ok_or_else(|| de::Error::invalid_length(3, &self))?;
                        Ok($vec4::$new_fn(x, y, z, w))
                    }
                }

                deserializer.deserialize_tuple_struct(stringify!($vec4), 4, Vec4Visitor)
            }
        }
    };
}

#[cfg(test)]
macro_rules! impl_serde_vec4_wide_test {
    ($t:ty, $vec4:ident) => {
        impl_serde_vec4_wide_test!($t, $vec4, test_vec4_serde);
    };
    ($t:ty, $vec4:ident, $test_name:ident) => {
        impl_serde_vec4_wide_test!($t, $vec4, $test_name, new);
    };
    ($t:ty, $vec4:ident, $test_name:ident, $new_fn:ident) => {
        #[test]
        fn $test_name() {
            let a = $vec4::$new_fn(ONE, TWO, THREE, FOUR);
            let serialized = serde_json::to_string(&a).unwrap();
            assert_eq!(SX4, serialized);
            let deserialized = serde_json::from_str(&serialized).unwrap();
            assert_eq!(a, deserialized);
            let deserialized = serde_json::from_str::<$vec4>(SX0);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$vec4>(SX1);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$vec4>(SX2);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$vec4>(SX3);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$vec4>(SX5);
            assert!(deserialized.is_err());
        }
    };
}
macro_rules! impl_serde_quat_wide {
    ($t:ty, $quat:ident) => {
        impl_serde_quat_wide!($t, $quat, test_quat_serde);
    };
    ($t:ty, $quat:ident, $test_name:ident) => {
        impl_serde_quat_wide!($t, $quat, $test_name, from_xyzw);
    };
    ($t:ty, $quat:ident, $test_name:ident, $new_fn:ident) => {
        impl Serialize for $quat {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                let mut state = serializer.serialize_tuple_struct(stringify!($quat), 4)?;
                state.serialize_field(&self.x)?;
                state.serialize_field(&self.y)?;
                state.serialize_field(&self.z)?;
                state.serialize_field(&self.w)?;
                state.end()
            }
        }

        impl<'de> Deserialize<'de> for $quat {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                struct QuatVisitor;

                impl<'de> Visitor<'de> for QuatVisitor {
                    type Value = $quat;

                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
                        formatter.write_str(concat!("struct ", stringify!($quat)))
                    }

                    fn visit_seq<V>(self, mut seq: V) -> Result<$quat, V::Error>
                    where
                        V: SeqAccess<'de>,
                    {
                        let x = seq
                            .next_element()?
                            .ok_or_else(|| de::Error::invalid_length(0, &self))?;
                        let y = seq
                            .next_element()?
                            .ok_or_else(|| de::Error::invalid_length(1, &self))?;
                        let z = seq
                            .next_element()?
                            .ok_or_else(|| de::Error::invalid_length(2, &self))?;
                        let w = seq
                            .next_element()?
                            .ok_or_else(|| de::Error::invalid_length(3, &self))?;
                        Ok($quat::$new_fn(x, y, z, w))
                    }
                }

                deserializer.deserialize_tuple_struct(stringify!($quat), 4, QuatVisitor)
            }
        }
    };
}

#[cfg(test)]
macro_rules! impl_serde_quat_wide_test {
    ($t:ty, $quat:ident) => {
        impl_serde_quat_wide_test!($t, $quat, test_quat_serde);
    };
    ($t:ty, $quat:ident, $test_name:ident) => {
        impl_serde_quat_wide_test!($t, $quat, $test_name, from_xyzw);
    };
    ($t:ty, $quat:ident, $test_name:ident, $new_fn:ident) => {
        #[test]
        fn $test_name() {
            let a = $quat::$new_fn(ONE, TWO, THREE, FOUR);
            let serialized = serde_json::to_string(&a).unwrap();
            assert_eq!(serialized, SX4);
            let deserialized = serde_json::from_str(&serialized).unwrap();
            assert_eq!(a, deserialized);
            let deserialized = serde_json::from_str::<$quat>(SX0);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$quat>(SX1);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$quat>(SX2);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$quat>(SX3);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$quat>(SX5);
            assert!(deserialized.is_err());
        }
    };
}

macro_rules! impl_serde_mat2_wide {
    ($t:ty, $mat2:ident) => {
        impl_serde_mat2_wide!($t, $mat2, test_mat2_serde);
    };
    ($t:ty, $mat2:ident, $test_name:ident) => {
        impl Serialize for $mat2 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                let f: &[_; 4] = self.as_ref();
                let mut state = serializer.serialize_tuple_struct(stringify!($mat2), 4)?;
                state.serialize_field(&f[0])?;
                state.serialize_field(&f[1])?;
                state.serialize_field(&f[2])?;
                state.serialize_field(&f[3])?;
                state.end()
            }
        }

        impl<'de> Deserialize<'de> for $mat2 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                struct Mat2Visitor;

                impl<'de> Visitor<'de> for Mat2Visitor {
                    type Value = $mat2;

                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
                        formatter.write_str(concat!("struct ", stringify!($mat2)))
                    }

                    fn visit_seq<V>(self, mut seq: V) -> Result<$mat2, V::Error>
                    where
                        V: SeqAccess<'de>,
                    {
                        let mut f = { [ZERO; 4] };
                        for i in 0..4 {
                            f[i] = seq
                                .next_element()?
                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
                        }
                        Ok($mat2::from_cols_array(&f))
                    }
                }

                deserializer.deserialize_tuple_struct(stringify!($mat2), 4, Mat2Visitor)
            }
        }
    };
}

#[cfg(test)]
macro_rules! impl_serde_mat2_wide_test {
    ($t:ty, $mat2:ident) => {
        impl_serde_mat2_wide_test!($t, $mat2, test_mat2_serde);
    };
    ($t:ty, $mat2:ident, $test_name:ident) => {
        #[test]
        fn $test_name() {
            let a = $mat2::from_cols_array(&[ONE, TWO, THREE, FOUR]);
            let serialized = serde_json::to_string(&a).unwrap();
            assert_eq!(serialized, SX4);
            let deserialized = serde_json::from_str(&serialized).unwrap();
            assert_eq!(a, deserialized);
            let deserialized = serde_json::from_str::<$mat2>(SX0);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$mat2>(SX1);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$mat2>(SX2);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$mat2>(SX3);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$mat2>(SX5);
            assert!(deserialized.is_err());
        }
    };
}

macro_rules! impl_serde_mat3_wide {
    ($t:ty, $mat3:ident) => {
        impl_serde_mat3_wide!($t, $mat3, test_mat3_serde);
    };
    ($t:ty, $mat3:ident, $test_name:ident) => {
        impl Serialize for $mat3 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                let (m00, m01, m02) = self.x_axis.into();
                let (m10, m11, m12) = self.y_axis.into();
                let (m20, m21, m22) = self.z_axis.into();

                let mut state = serializer.serialize_tuple_struct(stringify!($mat3), 9)?;
                state.serialize_field(&m00)?;
                state.serialize_field(&m01)?;
                state.serialize_field(&m02)?;
                state.serialize_field(&m10)?;
                state.serialize_field(&m11)?;
                state.serialize_field(&m12)?;
                state.serialize_field(&m20)?;
                state.serialize_field(&m21)?;
                state.serialize_field(&m22)?;
                state.end()
            }
        }

        impl<'de> Deserialize<'de> for $mat3 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                struct Mat3Visitor;

                impl<'de> Visitor<'de> for Mat3Visitor {
                    type Value = $mat3;

                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
                        formatter.write_str(concat!("struct ", stringify!($mat3)))
                    }

                    fn visit_seq<V>(self, mut seq: V) -> Result<$mat3, V::Error>
                    where
                        V: SeqAccess<'de>,
                    {
                        let mut f = { [ZERO; 9] };
                        for i in 0..9 {
                            f[i] = seq
                                .next_element()?
                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
                        }
                        Ok($mat3::from_cols_array(&f))
                    }
                }

                deserializer.deserialize_tuple_struct(stringify!($mat3), 9, Mat3Visitor)
            }
        }
    };
}

#[cfg(test)]
macro_rules! impl_serde_mat3_wide_test {
    ($t:ty, $mat3:ident) => {
        impl_serde_mat3_wide_test!($t, $mat3, test_mat3_serde);
    };
    ($t:ty, $mat3:ident, $test_name:ident) => {
        #[test]
        fn $test_name() {
            let a = $mat3::from_cols_array(&[ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE]);
            let serialized = serde_json::to_string(&a).unwrap();
            assert_eq!(serialized, SX9);
            let deserialized = serde_json::from_str(&serialized).unwrap();
            assert_eq!(a, deserialized);
            let deserialized = serde_json::from_str::<$mat3>(SX0);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$mat3>(SX1);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$mat3>(SX2);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$mat3>(SX3);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$mat3>(SX5);
            assert!(deserialized.is_err());
            let deserialized =
                serde_json::from_str::<$mat3>("[[[1.0, 1.0, 1.0, 1.0],[2.0, 2.0, 2.0, 2.0],[3.0, 3.0, 3.0, 3.0]],[[1.0, 1.0, 1.0, 1.0],[2.0, 2.0, 2.0, 2.0],[3.0, 3.0, 3.0, 3.0]],[[1.0, 1.0, 1.0, 1.0],[2.0, 2.0, 2.0, 2.0],[3.0, 3.0, 3.0, 3.0]]");
            assert!(deserialized.is_err());
        }
    };
}

macro_rules! impl_serde_mat4_wide {
    ($t:ty, $mat4:ident) => {
        impl_serde_mat4_wide!($t, $mat4, test_mat4_serde);
    };
    ($t:ty, $mat4:ident, $test_name:ident) => {
        impl Serialize for $mat4 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                let mut state = serializer.serialize_tuple_struct(stringify!($mat4), 16)?;
                for f in self.as_ref() {
                    state.serialize_field(f)?;
                }
                state.end()
            }
        }

        impl<'de> Deserialize<'de> for $mat4 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                struct Mat4Visitor;

                impl<'de> Visitor<'de> for Mat4Visitor {
                    type Value = $mat4;

                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
                        formatter.write_str(concat!("struct ", stringify!($mat4)))
                    }

                    fn visit_seq<V>(self, mut seq: V) -> Result<$mat4, V::Error>
                    where
                        V: SeqAccess<'de>,
                    {
                        let mut f = { [ZERO; 16] };
                        for i in 0..16 {
                            f[i] = seq
                                .next_element()?
                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
                        }
                        Ok($mat4::from_cols_array(&f))
                    }
                }

                deserializer.deserialize_tuple_struct(stringify!($mat4), 16, Mat4Visitor)
            }
        }
    };
}

#[cfg(test)]
macro_rules! impl_serde_mat4_wide_test {
    ($t:ty, $mat4:ident) => {
        impl_serde_mat4_wide_test!($t, $mat4, test_mat4_serde);
    };
    ($t:ty, $mat4:ident, $test_name:ident) => {
        #[test]
        fn $test_name() {
            let a = $mat4::from_cols_array(&[
                ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE, TEN, ELEVEN, TWELVE, THIRTEEN,
                FOURTEEN, FIFTEEN, SIXTEEN,
            ]);
            let serialized = serde_json::to_string(&a).unwrap();
            assert_eq!(
                serialized,
                "[[1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0],[3.0,3.0,3.0,3.0],[4.0,4.0,4.0,4.0],[5.0,5.0,5.0,5.0],[6.0,6.0,6.0,6.0],[7.0,7.0,7.0,7.0],[8.0,8.0,8.0,8.0],[9.0,9.0,9.0,9.0],[10.0,10.0,10.0,10.0],[11.0,11.0,11.0,11.0],[12.0,12.0,12.0,12.0],[13.0,13.0,13.0,13.0],[14.0,14.0,14.0,14.0],[15.0,15.0,15.0,15.0],[16.0,16.0,16.0,16.0]]"
            );
            let deserialized = serde_json::from_str(&serialized).unwrap();
            assert_eq!(a, deserialized);
            let deserialized = serde_json::from_str::<$mat4>(SX0);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$mat4>(SX1);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$mat4>(SX2);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$mat4>(SX3);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$mat4>(SX5);
            assert!(deserialized.is_err());
        }
    };
}

macro_rules! impl_serde_affine2_wide {
    ($t:ty, $affine2:ident) => {
        impl_serde_affine2_wide!($t, $affine2, test_affine2_serde);
    };
    ($t:ty, $affine2:ident, $test_name:ident) => {
        impl Serialize for $affine2 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                // Serialize column-wise as 3x4 matrix:
                let mut state = serializer.serialize_tuple_struct(stringify!($affine2), 6)?;
                state.serialize_field(&self.x_axis.x)?;
                state.serialize_field(&self.x_axis.y)?;
                state.serialize_field(&self.y_axis.x)?;
                state.serialize_field(&self.y_axis.y)?;
                state.serialize_field(&self.z_axis.x)?;
                state.serialize_field(&self.z_axis.y)?;
                state.end()
            }
        }

        impl<'de> Deserialize<'de> for $affine2 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                struct Affine2Visitor;

                impl<'de> Visitor<'de> for Affine2Visitor {
                    type Value = $affine2;

                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
                        formatter.write_str(concat!("struct ", stringify!($affine2)))
                    }

                    fn visit_seq<V>(self, mut seq: V) -> Result<$affine2, V::Error>
                    where
                        V: SeqAccess<'de>,
                    {
                        let mut f = [ZERO; 6];
                        for (i, v) in f.iter_mut().enumerate() {
                            *v = seq
                                .next_element()?
                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
                        }
                        Ok($affine2::from_cols_array(&f))
                    }
                }

                deserializer.deserialize_tuple_struct(stringify!($affine2), 6, Affine2Visitor)
            }
        }
    };
}
#[cfg(test)]
macro_rules! impl_serde_affine2_wide_test {
    ($t:ty, $affine2:ident) => {
        impl_serde_affine2_wide_test!($t, $affine2, test_affine2_serde);
    };
    ($t:ty, $affine2:ident, $test_name:ident) => {
        #[test]
        fn $test_name() {
            let a = $affine2::from_cols_array(&[ONE, ZERO, TWO, ZERO, THREE, FOUR]);
            let serialized = serde_json::to_string(&a).unwrap();
            assert_eq!(serialized, "[[1.0,1.0,1.0,1.0],[0.0,0.0,0.0,0.0],[2.0,2.0,2.0,2.0],[0.0,0.0,0.0,0.0],[3.0,3.0,3.0,3.0],[4.0,4.0,4.0,4.0]]");
            let deserialized = serde_json::from_str(&serialized).unwrap();
            assert_eq!(a, deserialized);

            let deserialized = serde_json::from_str::<$affine2>(SX0);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$affine2>(SX1);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$affine2>(SX2);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$affine2>(SX3);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$affine2>(SX5);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$affine2>("[[[1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0]],[[3.0,3.0,3.0,3.0],[4.0,4.0,4.0,4.0]],[[5.0,5.0,5.0,5.0],[6.0,6.0,6.0,6.0]]]");
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$affine2>(
                "[[[1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0],[3.0,3.0,3.0,3.0],[4.0,4.0,4.0,4.0]],[[5.0,5.0,5.0,5.0],[6.0,6.0,6.0,6.0],[7.0,7.0,7.0,7.0],[8.0,8.0,8.0,8.0]],[[9.0,9.0,9.0,9.0],[10.0,10.0,10.0,10.0],[11.0,11.0,11.0,11.0],[12.0,12.0,12.0,12.0]],[[13.0,13.0,13.0,13.0],[14.0,14.0,14.0,14.0],[15.0,15.0,15.0,15.0],[16.0,16.0,16.0,16.0]]]",
            );
            assert!(deserialized.is_err());
        }
    };
}

macro_rules! impl_serde_affine3_wide {
    ($t:ty, $affine3:ident) => {
        impl_serde_affine3_wide!($t, $affine3, test_affine3_serde);
    };
    ($t:ty, $affine3:ident, $test_name:ident) => {
        impl Serialize for $affine3 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                // Serialize column-wise as 3x4 matrix:
                let mut state = serializer.serialize_tuple_struct(stringify!($affine3), 12)?;
                state.serialize_field(&self.x_axis.x)?;
                state.serialize_field(&self.x_axis.y)?;
                state.serialize_field(&self.x_axis.z)?;
                state.serialize_field(&self.y_axis.x)?;
                state.serialize_field(&self.y_axis.y)?;
                state.serialize_field(&self.y_axis.z)?;
                state.serialize_field(&self.z_axis.x)?;
                state.serialize_field(&self.z_axis.y)?;
                state.serialize_field(&self.z_axis.z)?;
                state.serialize_field(&self.w_axis.x)?;
                state.serialize_field(&self.w_axis.y)?;
                state.serialize_field(&self.w_axis.z)?;
                state.end()
            }
        }

        impl<'de> Deserialize<'de> for $affine3 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                struct Affine3Visitor;

                impl<'de> Visitor<'de> for Affine3Visitor {
                    type Value = $affine3;

                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
                        formatter.write_str(concat!("struct ", stringify!($affine3)))
                    }

                    fn visit_seq<V>(self, mut seq: V) -> Result<$affine3, V::Error>
                    where
                        V: SeqAccess<'de>,
                    {
                        let mut f = [ZERO; 12];
                        for (i, v) in f.iter_mut().enumerate() {
                            *v = seq
                                .next_element()?
                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
                        }
                        Ok($affine3::from_cols_array(&f))
                    }
                }

                deserializer.deserialize_tuple_struct(stringify!($affine3), 12, Affine3Visitor)
            }
        }
    };
}

#[cfg(test)]
macro_rules! impl_serde_affine3_wide_test {
    ($t:ty, $affine3:ident) => {
        impl_serde_affine3_wide_test!($t, $affine3, test_affine3_serde);
    };
    ($t:ty, $affine3:ident, $test_name:ident) => {
        #[test]
        fn $test_name() {
            let a = $affine3::from_cols_array(&[
               ONE,ZERO,ZERO,ZERO,TWO,ZERO,ZERO,ZERO,THREE,FOUR,FIVE,SIX
            ]);
            let serialized = serde_json::to_string(&a).unwrap();
            assert_eq!(
                serialized,
                "[[1.0,1.0,1.0,1.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[2.0,2.0,2.0,2.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[3.0,3.0,3.0,3.0],[4.0,4.0,4.0,4.0],[5.0,5.0,5.0,5.0],[6.0,6.0,6.0,6.0]]"
            );
            let deserialized = serde_json::from_str(&serialized).unwrap();
            assert_eq!(a, deserialized);

            let deserialized = serde_json::from_str::<$affine3>(SX0);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$affine3>(SX1);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$affine3>(SX2);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$affine3>(SX3);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$affine3>(SX5);
            assert!(deserialized.is_err());
            let deserialized =
                serde_json::from_str::<$affine3>("[[[1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0],[3.0,3.0,3.0,3.0]],[[4.0,4.0,4.0,4.0],[5.0,5.0,5.0,5.0],[6.0,6.0,6.0,6.0]],[[7.0,7.0,7.0,7.0],[8.0,8.0,8.0,8.0],[9.0,9.0,9.0,9.0]]]");
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$affine3>(
                "[[[1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0],[3.0,3.0,3.0,3.0],[4.0,4.0,4.0,4.0]],[[5.0,5.0,5.0,5.0],[6.0,6.0,6.0,6.0],[7.0,7.0,7.0,7.0],[8.0,8.0,8.0,8.0]],[[9.0,9.0,9.0,9.0],[10.0,10.0,10.0,10.0],[11.0,11.0,11.0,11.0],[12.0,12.0,12.0,12.0]],[[13.0,13.0,13.0,13.0],[14.0,14.0,14.0,14.0],[15.0,15.0,15.0,15.0],[16.0,16.0,16.0,16.0]]]",
            );
            assert!(deserialized.is_err());
        }
    };
}

macro_rules! impl_serde_isometry3_wide {
    ($t:ty, $isometry3:ident) => {
        impl_serde_isometry3_wide!($t, $isometry3, test_isometry3_serde);
    };
    ($t:ty, $isometry3:ident, $test_name:ident) => {
        impl Serialize for $isometry3 {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: Serializer,
            {
                // Serialize column-wise as 3x4 matrix:
                let mut state = serializer.serialize_tuple_struct(stringify!($isometry3), 7)?;
                state.serialize_field(&self.rotation.x)?;
                state.serialize_field(&self.rotation.y)?;
                state.serialize_field(&self.rotation.z)?;
                state.serialize_field(&self.rotation.w)?;
                state.serialize_field(&self.translation.x)?;
                state.serialize_field(&self.translation.y)?;
                state.serialize_field(&self.translation.z)?;
                state.end()
            }
        }

        impl<'de> Deserialize<'de> for $isometry3 {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                struct Isometry3Visitor;

                impl<'de> Visitor<'de> for Isometry3Visitor {
                    type Value = $isometry3;

                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
                        formatter.write_str(concat!("struct ", stringify!($isometry3)))
                    }

                    fn visit_seq<V>(self, mut seq: V) -> Result<$isometry3, V::Error>
                    where
                        V: SeqAccess<'de>,
                    {
                        let mut f = [ZERO; 7];
                        for (i, v) in f.iter_mut().enumerate() {
                            *v = seq
                                .next_element()?
                                .ok_or_else(|| de::Error::invalid_length(i, &self))?;
                        }
                        Ok($isometry3::from_array_unchecked(&f))
                    }
                }

                deserializer.deserialize_tuple_struct(stringify!($isometry3), 7, Isometry3Visitor)
            }
        }
    };
}

#[cfg(test)]
macro_rules! impl_serde_isometry3_wide_test {
    ($t:ty, $isometry3:ident) => {
        impl_serde_isometry3_wide_test!($t, $isometry3, test_isometry3_serde);
    };
    ($t:ty, $isometry3:ident, $test_name:ident) => {
        #[test]
        fn $test_name() {
            let a = $isometry3::from_array_unchecked(&[ONE,ZERO,ZERO,ZERO,ONE,TWO,THREE]);
            let serialized = serde_json::to_string(&a).unwrap();
            assert_eq!(serialized, "[[1.0,1.0,1.0,1.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0],[3.0,3.0,3.0,3.0]]");
            let deserialized = serde_json::from_str(&serialized).unwrap();
            assert_eq!(a, deserialized);

            let deserialized = serde_json::from_str::<$isometry3>(SX0);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$isometry3>(SX1);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$isometry3>(SX2);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$isometry3>(SX3);
            assert!(deserialized.is_err());
            let deserialized = serde_json::from_str::<$isometry3>(SX4);
            assert!(deserialized.is_err());
            let deserialized =
                serde_json::from_str::<$isometry3>("[[[1.0,1.0,1.0,1.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0],[0.0,0.0,0.0,0.0]],[[1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0],[3.0,3.0,3.0,3.0]]]");
            assert!(deserialized.is_err());
        }
    };
}

mod f32x4 {

    use crate::nums::{f32x4, NumConstEx};
    use crate::{
        Affine2x4, Affine3x4, Isometry3x4, Mat2x4, Mat3x4, Mat4x4, Point2x4, Point3x4, Point4x4,
        Quatx4, UnitQuatx4, UnitVec2x4, UnitVec3x4, UnitVec4x4, Vec2x4, Vec3x4, Vec4x4,
    };
    use core::fmt;
    use serde::{
        de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
        ser::{Serialize, SerializeTupleStruct, Serializer},
    };

    pub const ZERO: f32x4 = f32x4::ZERO;

    impl_serde_vec2_wide!(f32x4, Vec2x4);
    impl_serde_vec3_wide!(f32x4, Vec3x4);
    impl_serde_vec4_wide!(f32x4, Vec4x4);
    impl_serde_affine2_wide!(f32x4, Affine2x4);
    impl_serde_affine3_wide!(f32x4, Affine3x4);
    impl_serde_isometry3_wide!(f32x4, Isometry3x4);
    impl_serde_mat2_wide!(f32x4, Mat2x4);
    impl_serde_mat3_wide!(f32x4, Mat3x4);
    impl_serde_mat4_wide!(f32x4, Mat4x4);
    impl_serde_quat_wide!(f32x4, Quatx4);
    impl_serde_vec2_wide!(f32x4, Point2x4, test_point2_serde);
    impl_serde_vec3_wide!(f32x4, Point3x4, test_point3_serde);
    impl_serde_vec4_wide!(f32x4, Point4x4, test_point4_serde);
    impl_serde_vec2_wide!(f32x4, UnitVec2x4, test_unit_vec2_serde, new_unchecked);
    impl_serde_vec3_wide!(f32x4, UnitVec3x4, test_unit_vec3_serde, new_unchecked);
    impl_serde_vec4_wide!(f32x4, UnitVec4x4, test_unit_vec4_serde, new_unchecked);
    impl_serde_quat_wide!(f32x4, UnitQuatx4, test_unit_quat_serde, from_xyzw_unchecked);

    #[cfg(test)]
    mod tests {
        use super::ZERO;
        use crate::nums::{f32x4, NumConstEx};
        use crate::{
            Affine2x4, Affine3x4, Isometry3x4, Mat2x4, Mat3x4, Mat4x4, Point2x4, Point3x4,
            Point4x4, Quatx4, UnitQuatx4, UnitVec2x4, UnitVec3x4, UnitVec4x4, Vec2x4, Vec3x4,
            Vec4x4,
        };
        impl_serde_vec2_wide_test!(f32x4, Vec2x4);
        impl_serde_vec3_wide_test!(f32x4, Vec3x4);
        impl_serde_vec4_wide_test!(f32x4, Vec4x4);
        impl_serde_affine2_wide_test!(f32x4, Affine2x4);
        impl_serde_affine3_wide_test!(f32x4, Affine3x4);
        impl_serde_isometry3_wide_test!(f32x4, Isometry3x4);
        impl_serde_mat2_wide_test!(f32x4, Mat2x4);
        impl_serde_mat3_wide_test!(f32x4, Mat3x4);
        impl_serde_mat4_wide_test!(f32x4, Mat4x4);
        impl_serde_quat_wide_test!(f32x4, Quatx4);
        impl_serde_vec2_wide_test!(f32x4, Point2x4, test_point2_serde);
        impl_serde_vec3_wide_test!(f32x4, Point3x4, test_point3_serde);
        impl_serde_vec4_wide_test!(f32x4, Point4x4, test_point4_serde);
        impl_serde_vec2_wide_test!(f32x4, UnitVec2x4, test_unit_vec2_serde, new_unchecked);
        impl_serde_vec3_wide_test!(f32x4, UnitVec3x4, test_unit_vec3_serde, new_unchecked);
        impl_serde_vec4_wide_test!(f32x4, UnitVec4x4, test_unit_vec4_serde, new_unchecked);
        impl_serde_quat_wide_test!(f32x4, UnitQuatx4, test_unit_quat_serde, from_xyzw_unchecked);

        pub const ONE: f32x4 = f32x4::ONE;
        pub const TWO: f32x4 = f32x4::TWO;
        pub const THREE: f32x4 = f32x4::const_splat(3.0);
        pub const FOUR: f32x4 = f32x4::const_splat(4.0);
        pub const FIVE: f32x4 = f32x4::const_splat(5.0);
        pub const SIX: f32x4 = f32x4::const_splat(6.0);
        pub const SEVEN: f32x4 = f32x4::const_splat(7.0);
        pub const EIGHT: f32x4 = f32x4::const_splat(8.0);
        pub const NINE: f32x4 = f32x4::const_splat(9.0);
        pub const TEN: f32x4 = f32x4::const_splat(10.0);
        pub const ELEVEN: f32x4 = f32x4::const_splat(11.0);
        pub const TWELVE: f32x4 = f32x4::const_splat(12.0);
        pub const THIRTEEN: f32x4 = f32x4::const_splat(13.0);
        pub const FOURTEEN: f32x4 = f32x4::const_splat(14.0);
        pub const FIFTEEN: f32x4 = f32x4::const_splat(15.0);
        pub const SIXTEEN: f32x4 = f32x4::const_splat(16.0);
        pub const SX0: &str = "[]";
        pub const SX1: &str = "[[1.0,1.0,1.0,1.0]]";
        pub const SX2: &str = "[[1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0]]";
        pub const SX3: &str = "[[1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0],[3.0,3.0,3.0,3.0]]";
        pub const SX4: &str =
            "[[1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0],[3.0,3.0,3.0,3.0],[4.0,4.0,4.0,4.0]]";
        pub const SX5: &str = "[[1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0],[3.0,3.0,3.0,3.0],[4.0,4.0,4.0,4.0],[5.0,5.0,5.0,5.0]]";
        pub const SX9: &str = "[[1.0,1.0,1.0,1.0],[2.0,2.0,2.0,2.0],[3.0,3.0,3.0,3.0],[4.0,4.0,4.0,4.0],[5.0,5.0,5.0,5.0],[6.0,6.0,6.0,6.0],[7.0,7.0,7.0,7.0],[8.0,8.0,8.0,8.0],[9.0,9.0,9.0,9.0]]";
    }
}