macro_rules! impl_serde_vec2 {
($t:ty, $vec2:ident) => {
impl_serde_vec2!($t, $vec2, test_vec2_serde);
};
($t:ty, $vec2:ident, $test_name:ident) => {
impl_serde_vec2!($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)
}
}
#[test]
fn $test_name() {
let a = $vec2::$new_fn(1 as $t, 2 as $t);
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 {
($t:ty, $vec3:ident) => {
impl_serde_vec3!($t, $vec3, test_vec3_serde);
};
($t:ty, $vec3:ident, $test_name:ident) => {
impl_serde_vec3!($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)
}
}
#[test]
fn $test_name() {
let a = $vec3::$new_fn(1 as $t, 2 as $t, 3 as $t);
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 {
($t:ty, $vec4:ident) => {
impl_serde_vec4!($t, $vec4, test_vec4_serde);
};
($t:ty, $vec4:ident, $test_name:ident) => {
impl_serde_vec4!($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)
}
}
#[test]
fn $test_name() {
let a = $vec4::$new_fn(1 as $t, 2 as $t, 3 as $t, 4 as $t);
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 {
($t:ty, $quat:ident) => {
impl_serde_quat!($t, $quat, test_quat_serde);
};
($t:ty, $quat:ident, $test_name:ident) => {
impl_serde_quat!($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)
}
}
#[test]
fn $test_name() {
let a = $quat::$new_fn(1.0, 2.0, 3.0, 4.0);
let serialized = serde_json::to_string(&a).unwrap();
assert_eq!(serialized, "[1.0,2.0,3.0,4.0]");
let deserialized = serde_json::from_str(&serialized).unwrap();
assert_eq!(a, deserialized);
let deserialized = serde_json::from_str::<$quat>("[]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$quat>("[1.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$quat>("[1.0,2.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$quat>("[1.0,2.0,3.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$quat>("[1.0,2.0,3.0,4.0,5.0]");
assert!(deserialized.is_err());
}
};
}
macro_rules! impl_serde_mat2 {
($t:ty, $mat2:ident) => {
impl_serde_mat2!($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 = { [0.0; 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)
}
}
#[test]
fn $test_name() {
let a = $mat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]);
let serialized = serde_json::to_string(&a).unwrap();
assert_eq!(serialized, "[1.0,2.0,3.0,4.0]");
let deserialized = serde_json::from_str(&serialized).unwrap();
assert_eq!(a, deserialized);
let deserialized = serde_json::from_str::<$mat2>("[]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$mat2>("[1.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$mat2>("[1.0,2.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$mat2>("[1.0,2.0,3.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$mat2>("[1.0,2.0,3.0,4.0,5.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$mat2>("[[1.0,2.0],[3.0,4.0]]");
assert!(deserialized.is_err());
}
};
}
macro_rules! impl_serde_mat3 {
($t:ty, $mat3:ident) => {
impl_serde_mat3!($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 = { [0.0; 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)
}
}
#[test]
fn $test_name() {
let a = $mat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]);
let serialized = serde_json::to_string(&a).unwrap();
assert_eq!(serialized, "[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0]");
let deserialized = serde_json::from_str(&serialized).unwrap();
assert_eq!(a, deserialized);
let deserialized = serde_json::from_str::<$mat3>("[]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$mat3>("[1.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$mat3>("[1.0,2.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$mat3>("[1.0,2.0,3.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$mat3>("[1.0,2.0,3.0,4.0,5.0]");
assert!(deserialized.is_err());
let deserialized =
serde_json::from_str::<$mat3>("[[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]]");
assert!(deserialized.is_err());
}
};
}
macro_rules! impl_serde_mat4 {
($t:ty, $mat4:ident) => {
impl_serde_mat4!($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 = { [0.0; 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)
}
}
#[test]
fn $test_name() {
let a = $mat4::from_cols_array(&[
1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0,
16.0,
]);
let serialized = serde_json::to_string(&a).unwrap();
assert_eq!(
serialized,
"[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0]"
);
let deserialized = serde_json::from_str(&serialized).unwrap();
assert_eq!(a, deserialized);
let deserialized = serde_json::from_str::<$mat4>("[]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$mat4>("[1.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$mat4>("[1.0,2.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$mat4>("[1.0,2.0,3.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$mat4>("[1.0,2.0,3.0,4.0,5.0]");
assert!(deserialized.is_err());
let deserialized =
serde_json::from_str::<$mat4>("[[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$mat4>(
"[[1.0,2.0,3.0,4.0],[5.0,6.0,7.0,8.0],[9.0,10.0,11.0,12.0][13.0,14.0,15.0,16.0]]",
);
assert!(deserialized.is_err());
}
};
}
macro_rules! impl_serde_affine2 {
($t:ty, $affine2:ident) => {
impl_serde_affine2!($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,
{
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 = [0.0; 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)
}
}
#[test]
fn $test_name() {
let a = $affine2::from_cols_array(&[1.0, 0.0, 2.0, 0.0, 3.0, 4.0]);
let serialized = serde_json::to_string(&a).unwrap();
assert_eq!(serialized, "[1.0,0.0,2.0,0.0,3.0,4.0]");
let deserialized = serde_json::from_str(&serialized).unwrap();
assert_eq!(a, deserialized);
let deserialized = serde_json::from_str::<$affine2>("[]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$affine2>("[1.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$affine2>("[1.0,2.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$affine2>("[1.0,2.0,3.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$affine2>("[1.0,2.0,3.0,4.0,5.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$affine2>("[[1.0,2.0],[3.0,4.0],[5.0,6.0]]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$affine2>(
"[[1.0,2.0,3.0,4.0],[5.0,6.0,7.0,8.0],[9.0,10.0,11.0,12.0][13.0,14.0,15.0,16.0]]",
);
assert!(deserialized.is_err());
}
};
}
macro_rules! impl_serde_affine3 {
($t:ty, $affine3:ident) => {
impl_serde_affine3!($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,
{
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 = [0.0; 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)
}
}
#[test]
fn $test_name() {
let a = $affine3::from_cols_array(&[
1.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 3.0, 4.0, 5.0, 6.0,
]);
let serialized = serde_json::to_string(&a).unwrap();
assert_eq!(
serialized,
"[1.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,3.0,4.0,5.0,6.0]"
);
let deserialized = serde_json::from_str(&serialized).unwrap();
assert_eq!(a, deserialized);
let deserialized = serde_json::from_str::<$affine3>("[]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$affine3>("[1.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$affine3>("[1.0,2.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$affine3>("[1.0,2.0,3.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$affine3>("[1.0,2.0,3.0,4.0,5.0]");
assert!(deserialized.is_err());
let deserialized =
serde_json::from_str::<$affine3>("[[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$affine3>(
"[[1.0,2.0,3.0,4.0],[5.0,6.0,7.0,8.0],[9.0,10.0,11.0,12.0][13.0,14.0,15.0,16.0]]",
);
assert!(deserialized.is_err());
}
};
}
macro_rules! impl_serde_isometry3 {
($t:ty, $isometry3:ident) => {
impl_serde_isometry3!($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,
{
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 = [0.0; 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)
}
}
#[test]
fn $test_name() {
let a = $isometry3::from_array_unchecked(&[1.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0]);
let serialized = serde_json::to_string(&a).unwrap();
assert_eq!(serialized, "[1.0,0.0,0.0,0.0,1.0,2.0,3.0]");
let deserialized = serde_json::from_str(&serialized).unwrap();
assert_eq!(a, deserialized);
let deserialized = serde_json::from_str::<$isometry3>("[]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$isometry3>("[1.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$isometry3>("[1.0,0.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$isometry3>("[1.0,0.0,0.0]");
assert!(deserialized.is_err());
let deserialized = serde_json::from_str::<$isometry3>("[1.0,0.0,0.0,0.0]");
assert!(deserialized.is_err());
let deserialized =
serde_json::from_str::<$isometry3>("[[1.0,0.0,0.0,0.0],[1.0,2.0,3.0]]");
assert!(deserialized.is_err());
assert!(deserialized.is_err());
}
};
}
#[cfg(test)]
mod test_float {
pub const SX0: &str = "[]";
pub const SX1: &str = "[1.0]";
pub const SX2: &str = "[1.0,2.0]";
pub const SX3: &str = "[1.0,2.0,3.0]";
pub const SX4: &str = "[1.0,2.0,3.0,4.0]";
pub const SX5: &str = "[1.0,2.0,3.0,4.0,5.0]";
}
#[cfg(test)]
mod test_int {
pub const SX0: &str = "[]";
pub const SX1: &str = "[1]";
pub const SX2: &str = "[1,2]";
pub const SX3: &str = "[1,2,3]";
pub const SX4: &str = "[1,2,3,4]";
pub const SX5: &str = "[1,2,3,4,5]";
}
mod f32 {
#[cfg(test)]
use super::test_float::*;
use crate::{
Affine2, Affine3A, Isometry3, Mat2, Mat3, Mat3A, Mat4, Point2, Point3, Point3A, Point4,
Quat, UnitQuat, UnitVec2, UnitVec3, UnitVec3A, UnitVec4, Vec2, Vec3, Vec3A, Vec4,
};
use core::fmt;
use serde::{
de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
ser::{Serialize, SerializeTupleStruct, Serializer},
};
impl_serde_vec2!(f32, Vec2);
impl_serde_vec3!(f32, Vec3);
impl_serde_vec4!(f32, Vec4);
impl_serde_affine2!(f32, Affine2);
impl_serde_affine3!(f32, Affine3A);
impl_serde_isometry3!(f32, Isometry3);
impl_serde_mat2!(f32, Mat2);
impl_serde_mat3!(f32, Mat3);
impl_serde_mat4!(f32, Mat4);
impl_serde_quat!(f32, Quat);
impl_serde_mat3!(f32, Mat3A, test_mat3a_serde);
impl_serde_vec3!(f32, Vec3A, test_vec3a_serde);
impl_serde_vec3!(f32, Point3A, test_point3a_serde);
impl_serde_vec2!(f32, Point2, test_point2_serde);
impl_serde_vec3!(f32, Point3, test_point3_serde);
impl_serde_vec4!(f32, Point4, test_point4_serde);
impl_serde_vec2!(f32, UnitVec2, test_unit_vec2_serde, new_unchecked);
impl_serde_vec3!(f32, UnitVec3, test_unit_vec3_serde, new_unchecked);
impl_serde_vec3!(f32, UnitVec3A, test_unit_vec3a_serde, new_unchecked);
impl_serde_vec4!(f32, UnitVec4, test_unit_vec4_serde, new_unchecked);
impl_serde_quat!(f32, UnitQuat, test_unit_quat_serde, from_xyzw_unchecked);
}
mod f64 {
#[cfg(test)]
use super::test_float::*;
use crate::{
DAffine2, DAffine3, DMat2, DMat3, DMat4, DPoint2, DPoint3, DPoint4, DQuat, DVec2, DVec3,
DVec4, UnitDQuat, UnitDVec2, UnitDVec3, UnitDVec4,
};
use core::fmt;
use serde::{
de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
ser::{Serialize, SerializeTupleStruct, Serializer},
};
impl_serde_vec2!(f64, DVec2);
impl_serde_vec3!(f64, DVec3);
impl_serde_vec4!(f64, DVec4);
impl_serde_affine2!(f64, DAffine2);
impl_serde_affine3!(f64, DAffine3);
impl_serde_mat2!(f64, DMat2);
impl_serde_mat3!(f64, DMat3);
impl_serde_mat4!(f64, DMat4);
impl_serde_quat!(f64, DQuat);
impl_serde_vec2!(f64, DPoint2, test_dpoint2_serde);
impl_serde_vec3!(f64, DPoint3, test_dpoint3_serde);
impl_serde_vec4!(f64, DPoint4, test_dpoint4_serde);
impl_serde_vec2!(f64, UnitDVec2, test_unit_dvec2_serde, new_unchecked);
impl_serde_vec3!(f64, UnitDVec3, test_unit_dvec3_serde, new_unchecked);
impl_serde_vec4!(f64, UnitDVec4, test_unit_dvec4_serde, new_unchecked);
impl_serde_quat!(f64, UnitDQuat, test_unit_dquat_serde, from_xyzw_unchecked);
}
mod i32 {
#[cfg(test)]
use super::test_int::*;
use crate::{IPoint2, IPoint3, IPoint4, IVec2, IVec3, IVec4};
use core::fmt;
use serde::{
de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
ser::{Serialize, SerializeTupleStruct, Serializer},
};
impl_serde_vec2!(i32, IVec2);
impl_serde_vec3!(i32, IVec3);
impl_serde_vec4!(i32, IVec4);
impl_serde_vec2!(i32, IPoint2, test_ipoint2_serde);
impl_serde_vec3!(i32, IPoint3, test_ipoint3_serde);
impl_serde_vec4!(i32, IPoint4, test_ipoint4_serde);
}
mod u32 {
#[cfg(test)]
use super::test_int::*;
use crate::{UPoint2, UPoint3, UPoint4, UVec2, UVec3, UVec4};
use core::fmt;
use serde::{
de::{self, Deserialize, Deserializer, SeqAccess, Visitor},
ser::{Serialize, SerializeTupleStruct, Serializer},
};
impl_serde_vec2!(u32, UVec2);
impl_serde_vec3!(u32, UVec3);
impl_serde_vec4!(u32, UVec4);
impl_serde_vec2!(u32, UPoint2, test_upoint2_serde);
impl_serde_vec3!(u32, UPoint3, test_upoint3_serde);
impl_serde_vec4!(u32, UPoint4, test_upoint4_serde);
}