1 macro_rules! impl_serde_vec2 { 2 ($t:ty, $vec2:ident) => { 3 /// Serialize as a sequence of 2 values. 4 impl Serialize for $vec2 { 5 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 6 where 7 S: Serializer, 8 { 9 let mut state = serializer.serialize_tuple_struct(stringify!($vec2), 2)?; 10 state.serialize_field(&self.x)?; 11 state.serialize_field(&self.y)?; 12 state.end() 13 } 14 } 15 16 /// Deserialize expects a sequence of 2 values. 17 impl<'de> Deserialize<'de> for $vec2 { 18 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 19 where 20 D: Deserializer<'de>, 21 { 22 struct Vec2Visitor; 23 24 impl<'de> Visitor<'de> for Vec2Visitor { 25 type Value = $vec2; 26 27 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 28 formatter.write_str(&concat!("a sequence of 2 ", stringify!($t), " values")) 29 } 30 31 fn visit_seq<V>(self, mut seq: V) -> Result<$vec2, V::Error> 32 where 33 V: SeqAccess<'de>, 34 { 35 let x = seq 36 .next_element()? 37 .ok_or_else(|| de::Error::invalid_length(0, &self))?; 38 let y = seq 39 .next_element()? 40 .ok_or_else(|| de::Error::invalid_length(1, &self))?; 41 Ok($vec2::new(x, y)) 42 } 43 } 44 45 deserializer.deserialize_tuple_struct(stringify!($vec2), 2, Vec2Visitor) 46 } 47 } 48 49 #[test] 50 fn test_vec2_serde() { 51 let a = $vec2::new(V1, V2); 52 let serialized = serde_json::to_string(&a).unwrap(); 53 assert_eq!(SX2, serialized); 54 let deserialized = serde_json::from_str(&serialized).unwrap(); 55 assert_eq!(a, deserialized); 56 let deserialized = serde_json::from_str::<$vec2>(SX0); 57 assert!(deserialized.is_err()); 58 let deserialized = serde_json::from_str::<$vec2>(SX1); 59 assert!(deserialized.is_err()); 60 let deserialized = serde_json::from_str::<$vec2>(SX3); 61 assert!(deserialized.is_err()); 62 63 let deserialized = serde_json::from_str::<$vec2>(ST0); 64 assert!(deserialized.is_err()); 65 } 66 }; 67 } 68 69 macro_rules! impl_serde_vec3 { 70 ($t:ty, $vec3:ident) => { 71 impl_serde_vec3!($t, $vec3, test_vec3_serde); 72 }; 73 ($t:ty, $vec3:ident, $test_name:ident) => { 74 /// Serialize as a sequence of 3 values. 75 impl Serialize for $vec3 { 76 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 77 where 78 S: Serializer, 79 { 80 let mut state = serializer.serialize_tuple_struct(stringify!($vec3), 3)?; 81 state.serialize_field(&self.x)?; 82 state.serialize_field(&self.y)?; 83 state.serialize_field(&self.z)?; 84 state.end() 85 } 86 } 87 88 /// Deserialize expects a sequence of 3 values. 89 impl<'de> Deserialize<'de> for $vec3 { 90 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 91 where 92 D: Deserializer<'de>, 93 { 94 struct Vec3Visitor; 95 96 impl<'de> Visitor<'de> for Vec3Visitor { 97 type Value = $vec3; 98 99 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 100 formatter.write_str(&concat!("a sequence of 3 ", stringify!($t), " values")) 101 } 102 103 fn visit_seq<V>(self, mut seq: V) -> Result<$vec3, V::Error> 104 where 105 V: SeqAccess<'de>, 106 { 107 let x = seq 108 .next_element()? 109 .ok_or_else(|| de::Error::invalid_length(0, &self))?; 110 let y = seq 111 .next_element()? 112 .ok_or_else(|| de::Error::invalid_length(1, &self))?; 113 let z = seq 114 .next_element()? 115 .ok_or_else(|| de::Error::invalid_length(2, &self))?; 116 Ok($vec3::new(x, y, z)) 117 } 118 } 119 120 deserializer.deserialize_tuple_struct(stringify!($vec3), 3, Vec3Visitor) 121 } 122 } 123 124 #[test] 125 fn $test_name() { 126 let a = $vec3::new(V1, V2, V3); 127 let serialized = serde_json::to_string(&a).unwrap(); 128 assert_eq!(SX3, serialized); 129 let deserialized = serde_json::from_str(&serialized).unwrap(); 130 assert_eq!(a, deserialized); 131 let deserialized = serde_json::from_str::<$vec3>(SX0); 132 assert!(deserialized.is_err()); 133 let deserialized = serde_json::from_str::<$vec3>(SX1); 134 assert!(deserialized.is_err()); 135 let deserialized = serde_json::from_str::<$vec3>(SX2); 136 assert!(deserialized.is_err()); 137 let deserialized = serde_json::from_str::<$vec3>(SX4); 138 assert!(deserialized.is_err()); 139 let deserialized = serde_json::from_str::<$vec3>(ST0); 140 assert!(deserialized.is_err()); 141 } 142 }; 143 } 144 145 macro_rules! impl_serde_vec4 { 146 ($t:ty, $vec4:ident) => { 147 /// Serialize as a sequence of 4 values. 148 impl Serialize for $vec4 { 149 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 150 where 151 S: Serializer, 152 { 153 let mut state = serializer.serialize_tuple_struct(stringify!($vec4), 4)?; 154 state.serialize_field(&self.x)?; 155 state.serialize_field(&self.y)?; 156 state.serialize_field(&self.z)?; 157 state.serialize_field(&self.w)?; 158 state.end() 159 } 160 } 161 162 /// Deserialize expects a sequence of 4 values. 163 impl<'de> Deserialize<'de> for $vec4 { 164 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 165 where 166 D: Deserializer<'de>, 167 { 168 struct Vec4Visitor; 169 170 impl<'de> Visitor<'de> for Vec4Visitor { 171 type Value = $vec4; 172 173 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 174 formatter.write_str(&concat!("a sequence of 4 ", stringify!($t), " values")) 175 } 176 177 fn visit_seq<V>(self, mut seq: V) -> Result<$vec4, V::Error> 178 where 179 V: SeqAccess<'de>, 180 { 181 let x = seq 182 .next_element()? 183 .ok_or_else(|| de::Error::invalid_length(0, &self))?; 184 let y = seq 185 .next_element()? 186 .ok_or_else(|| de::Error::invalid_length(1, &self))?; 187 let z = seq 188 .next_element()? 189 .ok_or_else(|| de::Error::invalid_length(2, &self))?; 190 let w = seq 191 .next_element()? 192 .ok_or_else(|| de::Error::invalid_length(3, &self))?; 193 Ok($vec4::new(x, y, z, w)) 194 } 195 } 196 197 deserializer.deserialize_tuple_struct(stringify!($vec4), 4, Vec4Visitor) 198 } 199 } 200 201 #[test] 202 fn test_vec4_serde() { 203 let a = $vec4::new(V1, V2, V3, V4); 204 let serialized = serde_json::to_string(&a).unwrap(); 205 assert_eq!(SX4, serialized); 206 let deserialized = serde_json::from_str(&serialized).unwrap(); 207 assert_eq!(a, deserialized); 208 let deserialized = serde_json::from_str::<$vec4>(SX0); 209 assert!(deserialized.is_err()); 210 let deserialized = serde_json::from_str::<$vec4>(SX1); 211 assert!(deserialized.is_err()); 212 let deserialized = serde_json::from_str::<$vec4>(SX2); 213 assert!(deserialized.is_err()); 214 let deserialized = serde_json::from_str::<$vec4>(SX3); 215 assert!(deserialized.is_err()); 216 let deserialized = serde_json::from_str::<$vec4>(SX5); 217 assert!(deserialized.is_err()); 218 let deserialized = serde_json::from_str::<$vec4>(ST0); 219 assert!(deserialized.is_err()); 220 } 221 }; 222 } 223 224 macro_rules! impl_serde_quat { 225 ($t:ty, $quat:ident) => { 226 /// Serialize as a sequence of 4 values. 227 impl Serialize for $quat { 228 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 229 where 230 S: Serializer, 231 { 232 let mut state = serializer.serialize_tuple_struct(stringify!($quat), 4)?; 233 state.serialize_field(&self.x)?; 234 state.serialize_field(&self.y)?; 235 state.serialize_field(&self.z)?; 236 state.serialize_field(&self.w)?; 237 state.end() 238 } 239 } 240 241 /// Deserialize expects a sequence of 4 values. 242 impl<'de> Deserialize<'de> for $quat { 243 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 244 where 245 D: Deserializer<'de>, 246 { 247 struct QuatVisitor; 248 249 impl<'de> Visitor<'de> for QuatVisitor { 250 type Value = $quat; 251 252 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 253 formatter.write_str(&concat!("a sequence of 4 ", stringify!($t), " values")) 254 } 255 256 fn visit_seq<V>(self, mut seq: V) -> Result<$quat, V::Error> 257 where 258 V: SeqAccess<'de>, 259 { 260 let x = seq 261 .next_element()? 262 .ok_or_else(|| de::Error::invalid_length(0, &self))?; 263 let y = seq 264 .next_element()? 265 .ok_or_else(|| de::Error::invalid_length(1, &self))?; 266 let z = seq 267 .next_element()? 268 .ok_or_else(|| de::Error::invalid_length(2, &self))?; 269 let w = seq 270 .next_element()? 271 .ok_or_else(|| de::Error::invalid_length(3, &self))?; 272 Ok($quat::from_xyzw(x, y, z, w)) 273 } 274 } 275 276 deserializer.deserialize_tuple_struct(stringify!($quat), 4, QuatVisitor) 277 } 278 } 279 280 #[test] 281 fn test_quat_serde() { 282 let a = $quat::from_xyzw(1.0, 2.0, 3.0, 4.0); 283 let serialized = serde_json::to_string(&a).unwrap(); 284 assert_eq!(serialized, "[1.0,2.0,3.0,4.0]"); 285 let deserialized = serde_json::from_str(&serialized).unwrap(); 286 assert_eq!(a, deserialized); 287 let deserialized = serde_json::from_str::<$quat>("[]"); 288 assert!(deserialized.is_err()); 289 let deserialized = serde_json::from_str::<$quat>("[1.0]"); 290 assert!(deserialized.is_err()); 291 let deserialized = serde_json::from_str::<$quat>("[1.0,2.0]"); 292 assert!(deserialized.is_err()); 293 let deserialized = serde_json::from_str::<$quat>("[1.0,2.0,3.0]"); 294 assert!(deserialized.is_err()); 295 let deserialized = serde_json::from_str::<$quat>("[1.0,2.0,3.0,4.0,5.0]"); 296 assert!(deserialized.is_err()); 297 let deserialized = serde_json::from_str::<$quat>("{}"); 298 assert!(deserialized.is_err()); 299 } 300 }; 301 } 302 303 macro_rules! impl_serde_mat2 { 304 ($t:ty, $mat2:ident) => { 305 /// Serialize as a sequence of 4 values. 306 impl Serialize for $mat2 { 307 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 308 where 309 S: Serializer, 310 { 311 let f: &[_; 4] = self.as_ref(); 312 let mut state = serializer.serialize_tuple_struct(stringify!($mat2), 4)?; 313 state.serialize_field(&f[0])?; 314 state.serialize_field(&f[1])?; 315 state.serialize_field(&f[2])?; 316 state.serialize_field(&f[3])?; 317 state.end() 318 } 319 } 320 321 /// Deserialize expects a sequence of 4 values. 322 impl<'de> Deserialize<'de> for $mat2 { 323 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 324 where 325 D: Deserializer<'de>, 326 { 327 struct Mat2Visitor; 328 329 impl<'de> Visitor<'de> for Mat2Visitor { 330 type Value = $mat2; 331 332 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 333 formatter.write_str(&concat!("a sequence of 4 ", stringify!($t), "values")) 334 } 335 336 fn visit_seq<V>(self, mut seq: V) -> Result<$mat2, V::Error> 337 where 338 V: SeqAccess<'de>, 339 { 340 let mut f = { [0.0; 4] }; 341 for i in 0..4 { 342 f[i] = seq 343 .next_element()? 344 .ok_or_else(|| de::Error::invalid_length(i, &self))?; 345 } 346 Ok($mat2::from_cols_array(&f)) 347 } 348 } 349 350 deserializer.deserialize_tuple_struct(stringify!($mat2), 4, Mat2Visitor) 351 } 352 } 353 354 #[test] 355 fn test_mat2_serde() { 356 let a = $mat2::from_cols_array(&[1.0, 2.0, 3.0, 4.0]); 357 let serialized = serde_json::to_string(&a).unwrap(); 358 assert_eq!(serialized, "[1.0,2.0,3.0,4.0]"); 359 let deserialized = serde_json::from_str(&serialized).unwrap(); 360 assert_eq!(a, deserialized); 361 let deserialized = serde_json::from_str::<$mat2>("[]"); 362 assert!(deserialized.is_err()); 363 let deserialized = serde_json::from_str::<$mat2>("[1.0]"); 364 assert!(deserialized.is_err()); 365 let deserialized = serde_json::from_str::<$mat2>("[1.0,2.0]"); 366 assert!(deserialized.is_err()); 367 let deserialized = serde_json::from_str::<$mat2>("[1.0,2.0,3.0]"); 368 assert!(deserialized.is_err()); 369 let deserialized = serde_json::from_str::<$mat2>("[1.0,2.0,3.0,4.0,5.0]"); 370 assert!(deserialized.is_err()); 371 let deserialized = serde_json::from_str::<$mat2>("[[1.0,2.0],[3.0,4.0]]"); 372 assert!(deserialized.is_err()); 373 let deserialized = serde_json::from_str::<$mat2>("{}"); 374 assert!(deserialized.is_err()); 375 } 376 }; 377 } 378 379 macro_rules! impl_serde_mat3 { 380 ($t:ty, $mat3:ident) => { 381 impl_serde_mat3!($t, $mat3, test_mat3_serde); 382 }; 383 ($t:ty, $mat3:ident, $test_name:ident) => { 384 /// Serialize as a sequence of 9 values. 385 impl Serialize for $mat3 { 386 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 387 where 388 S: Serializer, 389 { 390 let (m00, m01, m02) = self.x_axis.into(); 391 let (m10, m11, m12) = self.y_axis.into(); 392 let (m20, m21, m22) = self.z_axis.into(); 393 394 let mut state = serializer.serialize_tuple_struct(stringify!($mat3), 9)?; 395 state.serialize_field(&m00)?; 396 state.serialize_field(&m01)?; 397 state.serialize_field(&m02)?; 398 state.serialize_field(&m10)?; 399 state.serialize_field(&m11)?; 400 state.serialize_field(&m12)?; 401 state.serialize_field(&m20)?; 402 state.serialize_field(&m21)?; 403 state.serialize_field(&m22)?; 404 state.end() 405 } 406 } 407 408 /// Deserialize expects a sequence of 9 values. 409 impl<'de> Deserialize<'de> for $mat3 { 410 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 411 where 412 D: Deserializer<'de>, 413 { 414 struct Mat3Visitor; 415 416 impl<'de> Visitor<'de> for Mat3Visitor { 417 type Value = $mat3; 418 419 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 420 formatter.write_str(&concat!("a sequence of 9 ", stringify!($t), "values")) 421 } 422 423 fn visit_seq<V>(self, mut seq: V) -> Result<$mat3, V::Error> 424 where 425 V: SeqAccess<'de>, 426 { 427 let mut f = { [0.0; 9] }; 428 for i in 0..9 { 429 f[i] = seq 430 .next_element()? 431 .ok_or_else(|| de::Error::invalid_length(i, &self))?; 432 } 433 Ok($mat3::from_cols_array(&f)) 434 } 435 } 436 437 deserializer.deserialize_tuple_struct(stringify!($mat3), 9, Mat3Visitor) 438 } 439 } 440 441 #[test] 442 fn $test_name() { 443 let a = $mat3::from_cols_array(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]); 444 let serialized = serde_json::to_string(&a).unwrap(); 445 assert_eq!(serialized, "[1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0]"); 446 let deserialized = serde_json::from_str(&serialized).unwrap(); 447 assert_eq!(a, deserialized); 448 let deserialized = serde_json::from_str::<$mat3>("[]"); 449 assert!(deserialized.is_err()); 450 let deserialized = serde_json::from_str::<$mat3>("[1.0]"); 451 assert!(deserialized.is_err()); 452 let deserialized = serde_json::from_str::<$mat3>("[1.0,2.0]"); 453 assert!(deserialized.is_err()); 454 let deserialized = serde_json::from_str::<$mat3>("[1.0,2.0,3.0]"); 455 assert!(deserialized.is_err()); 456 let deserialized = serde_json::from_str::<$mat3>("[1.0,2.0,3.0,4.0,5.0]"); 457 assert!(deserialized.is_err()); 458 let deserialized = 459 serde_json::from_str::<$mat3>("[[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]]"); 460 assert!(deserialized.is_err()); 461 let deserialized = serde_json::from_str::<$mat3>("{}"); 462 assert!(deserialized.is_err()); 463 } 464 }; 465 } 466 467 macro_rules! impl_serde_mat4 { 468 ($t:ty, $mat4:ident) => { 469 /// Serialize as a sequence of 16 values. 470 impl Serialize for $mat4 { 471 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 472 where 473 S: Serializer, 474 { 475 let mut state = serializer.serialize_tuple_struct(stringify!($mat4), 16)?; 476 for f in self.as_ref() { 477 state.serialize_field(f)?; 478 } 479 state.end() 480 } 481 } 482 483 /// Deserialize expects a sequence of 16 values. 484 impl<'de> Deserialize<'de> for $mat4 { 485 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 486 where 487 D: Deserializer<'de>, 488 { 489 struct Mat4Visitor; 490 491 impl<'de> Visitor<'de> for Mat4Visitor { 492 type Value = $mat4; 493 494 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 495 formatter.write_str(&concat!("a sequence of 16 ", stringify!($t), "values")) 496 } 497 498 fn visit_seq<V>(self, mut seq: V) -> Result<$mat4, V::Error> 499 where 500 V: SeqAccess<'de>, 501 { 502 let mut f = { [0.0; 16] }; 503 for i in 0..16 { 504 f[i] = seq 505 .next_element()? 506 .ok_or_else(|| de::Error::invalid_length(i, &self))?; 507 } 508 Ok($mat4::from_cols_array(&f)) 509 } 510 } 511 512 deserializer.deserialize_tuple_struct(stringify!($mat4), 16, Mat4Visitor) 513 } 514 } 515 516 #[test] 517 fn test_mat4_serde() { 518 let a = $mat4::from_cols_array(&[ 519 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, 520 16.0, 521 ]); 522 let serialized = serde_json::to_string(&a).unwrap(); 523 assert_eq!( 524 serialized, 525 "[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]" 526 ); 527 let deserialized = serde_json::from_str(&serialized).unwrap(); 528 assert_eq!(a, deserialized); 529 let deserialized = serde_json::from_str::<$mat4>("[]"); 530 assert!(deserialized.is_err()); 531 let deserialized = serde_json::from_str::<$mat4>("[1.0]"); 532 assert!(deserialized.is_err()); 533 let deserialized = serde_json::from_str::<$mat4>("[1.0,2.0]"); 534 assert!(deserialized.is_err()); 535 let deserialized = serde_json::from_str::<$mat4>("[1.0,2.0,3.0]"); 536 assert!(deserialized.is_err()); 537 let deserialized = serde_json::from_str::<$mat4>("[1.0,2.0,3.0,4.0,5.0]"); 538 assert!(deserialized.is_err()); 539 let deserialized = 540 serde_json::from_str::<$mat4>("[[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]]"); 541 assert!(deserialized.is_err()); 542 let deserialized = serde_json::from_str::<$mat4>( 543 "[[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]]", 544 ); 545 assert!(deserialized.is_err()); 546 let deserialized = serde_json::from_str::<$mat4>("{}"); 547 assert!(deserialized.is_err()); 548 } 549 }; 550 } 551 552 macro_rules! impl_serde_affine2 { 553 ($t:ty, $affine2:ident) => { 554 /// Serialize as a sequence of 6 values. 555 impl Serialize for $affine2 { 556 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 557 where 558 S: Serializer, 559 { 560 // Serialize column-wise as 3x4 matrix: 561 let mut state = serializer.serialize_tuple_struct(stringify!($affine2), 6)?; 562 state.serialize_field(&self.x_axis.x)?; 563 state.serialize_field(&self.x_axis.y)?; 564 state.serialize_field(&self.y_axis.x)?; 565 state.serialize_field(&self.y_axis.y)?; 566 state.serialize_field(&self.z_axis.x)?; 567 state.serialize_field(&self.z_axis.y)?; 568 state.end() 569 } 570 } 571 572 /// Deserialize expects a sequence of 6 values. 573 impl<'de> Deserialize<'de> for $affine2 { 574 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 575 where 576 D: Deserializer<'de>, 577 { 578 struct Affine2Visitor; 579 580 impl<'de> Visitor<'de> for Affine2Visitor { 581 type Value = $affine2; 582 583 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 584 formatter.write_str(&concat!("a sequence of 6 ", stringify!($t), "values")) 585 } 586 587 fn visit_seq<V>(self, mut seq: V) -> Result<$affine2, V::Error> 588 where 589 V: SeqAccess<'de>, 590 { 591 let mut f = [0.0; 6]; 592 for (i, v) in f.iter_mut().enumerate() { 593 *v = seq 594 .next_element()? 595 .ok_or_else(|| de::Error::invalid_length(i, &self))?; 596 } 597 Ok($affine2::from_cols_array(&f)) 598 } 599 } 600 601 deserializer.deserialize_tuple_struct(stringify!($affine2), 6, Affine2Visitor) 602 } 603 } 604 605 #[test] 606 fn test_affine2_serde() { 607 let a = $affine2::from_cols_array(&[1.0, 0.0, 2.0, 0.0, 3.0, 4.0]); 608 let serialized = serde_json::to_string(&a).unwrap(); 609 assert_eq!(serialized, "[1.0,0.0,2.0,0.0,3.0,4.0]"); 610 let deserialized = serde_json::from_str(&serialized).unwrap(); 611 assert_eq!(a, deserialized); 612 613 let deserialized = serde_json::from_str::<$affine2>("[]"); 614 assert!(deserialized.is_err()); 615 let deserialized = serde_json::from_str::<$affine2>("[1.0]"); 616 assert!(deserialized.is_err()); 617 let deserialized = serde_json::from_str::<$affine2>("[1.0,2.0]"); 618 assert!(deserialized.is_err()); 619 let deserialized = serde_json::from_str::<$affine2>("[1.0,2.0,3.0]"); 620 assert!(deserialized.is_err()); 621 let deserialized = serde_json::from_str::<$affine2>("[1.0,2.0,3.0,4.0,5.0]"); 622 assert!(deserialized.is_err()); 623 let deserialized = serde_json::from_str::<$affine2>("[[1.0,2.0],[3.0,4.0],[5.0,6.0]]"); 624 assert!(deserialized.is_err()); 625 let deserialized = serde_json::from_str::<$affine2>( 626 "[[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]]", 627 ); 628 assert!(deserialized.is_err()); 629 let deserialized = serde_json::from_str::<$affine2>("{}"); 630 assert!(deserialized.is_err()); 631 } 632 }; 633 } 634 635 macro_rules! impl_serde_affine3 { 636 ($t:ty, $affine3:ident) => { 637 /// Serialize as a sequence of 12 values. 638 impl Serialize for $affine3 { 639 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 640 where 641 S: Serializer, 642 { 643 // Serialize column-wise as 3x4 matrix: 644 let mut state = serializer.serialize_tuple_struct(stringify!($affine3), 12)?; 645 state.serialize_field(&self.x_axis.x)?; 646 state.serialize_field(&self.x_axis.y)?; 647 state.serialize_field(&self.x_axis.z)?; 648 state.serialize_field(&self.y_axis.x)?; 649 state.serialize_field(&self.y_axis.y)?; 650 state.serialize_field(&self.y_axis.z)?; 651 state.serialize_field(&self.z_axis.x)?; 652 state.serialize_field(&self.z_axis.y)?; 653 state.serialize_field(&self.z_axis.z)?; 654 state.serialize_field(&self.w_axis.x)?; 655 state.serialize_field(&self.w_axis.y)?; 656 state.serialize_field(&self.w_axis.z)?; 657 state.end() 658 } 659 } 660 661 /// Deserialize expects a sequence of 12 values. 662 impl<'de> Deserialize<'de> for $affine3 { 663 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 664 where 665 D: Deserializer<'de>, 666 { 667 struct Affine3Visitor; 668 669 impl<'de> Visitor<'de> for Affine3Visitor { 670 type Value = $affine3; 671 672 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 673 formatter.write_str(&concat!("a sequence of 12 ", stringify!($t), "values")) 674 } 675 676 fn visit_seq<V>(self, mut seq: V) -> Result<$affine3, V::Error> 677 where 678 V: SeqAccess<'de>, 679 { 680 let mut f = [0.0; 12]; 681 for (i, v) in f.iter_mut().enumerate() { 682 *v = seq 683 .next_element()? 684 .ok_or_else(|| de::Error::invalid_length(i, &self))?; 685 } 686 Ok($affine3::from_cols_array(&f)) 687 } 688 } 689 690 deserializer.deserialize_tuple_struct(stringify!($affine3), 12, Affine3Visitor) 691 } 692 } 693 694 #[test] 695 fn test_affine3_serde() { 696 let a = $affine3::from_cols_array(&[ 697 1.0, 0.0, 0.0, 0.0, 2.0, 0.0, 0.0, 0.0, 3.0, 4.0, 5.0, 6.0, 698 ]); 699 let serialized = serde_json::to_string(&a).unwrap(); 700 assert_eq!( 701 serialized, 702 "[1.0,0.0,0.0,0.0,2.0,0.0,0.0,0.0,3.0,4.0,5.0,6.0]" 703 ); 704 let deserialized = serde_json::from_str(&serialized).unwrap(); 705 assert_eq!(a, deserialized); 706 707 let deserialized = serde_json::from_str::<$affine3>("[]"); 708 assert!(deserialized.is_err()); 709 let deserialized = serde_json::from_str::<$affine3>("[1.0]"); 710 assert!(deserialized.is_err()); 711 let deserialized = serde_json::from_str::<$affine3>("[1.0,2.0]"); 712 assert!(deserialized.is_err()); 713 let deserialized = serde_json::from_str::<$affine3>("[1.0,2.0,3.0]"); 714 assert!(deserialized.is_err()); 715 let deserialized = serde_json::from_str::<$affine3>("[1.0,2.0,3.0,4.0,5.0]"); 716 assert!(deserialized.is_err()); 717 let deserialized = 718 serde_json::from_str::<$affine3>("[[1.0,2.0,3.0],[4.0,5.0,6.0],[7.0,8.0,9.0]]"); 719 assert!(deserialized.is_err()); 720 let deserialized = serde_json::from_str::<$affine3>( 721 "[[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]]", 722 ); 723 assert!(deserialized.is_err()); 724 let deserialized = serde_json::from_str::<$affine3>("{}"); 725 assert!(deserialized.is_err()); 726 } 727 }; 728 } 729 730 macro_rules! impl_serde_vec_types { 731 ($t:ty, $vec2:ident, $vec3:ident, $vec4:ident) => { 732 impl_serde_vec2!($t, $vec2); 733 impl_serde_vec3!($t, $vec3); 734 impl_serde_vec4!($t, $vec4); 735 }; 736 } 737 738 macro_rules! impl_serde_float_types { 739 ($t:ty, $affine2:ident, $affine3:ident, $mat2:ident, $mat3:ident, $mat4:ident, $quat:ident, $vec2:ident, $vec3:ident, $vec4:ident) => { 740 impl_serde_affine2!($t, $affine2); 741 impl_serde_affine3!($t, $affine3); 742 impl_serde_mat2!($t, $mat2); 743 impl_serde_mat3!($t, $mat3); 744 impl_serde_mat4!($t, $mat4); 745 impl_serde_quat!($t, $quat); 746 impl_serde_vec_types!($t, $vec2, $vec3, $vec4); 747 }; 748 } 749 750 #[cfg(test)] 751 mod test_f32 { 752 pub const V1: f32 = 1.0; 753 pub const V2: f32 = 2.0; 754 pub const V3: f32 = 3.0; 755 pub const V4: f32 = 4.0; 756 } 757 758 #[cfg(test)] 759 mod test_f64 { 760 pub const V1: f64 = 1.0; 761 pub const V2: f64 = 2.0; 762 pub const V3: f64 = 3.0; 763 pub const V4: f64 = 4.0; 764 } 765 766 #[cfg(test)] 767 mod test_i8 { 768 pub const V1: i8 = 1; 769 pub const V2: i8 = 2; 770 pub const V3: i8 = 3; 771 pub const V4: i8 = 4; 772 } 773 774 #[cfg(test)] 775 mod test_i16 { 776 pub const V1: i16 = 1; 777 pub const V2: i16 = 2; 778 pub const V3: i16 = 3; 779 pub const V4: i16 = 4; 780 } 781 782 #[cfg(test)] 783 mod test_i32 { 784 pub const V1: i32 = 1; 785 pub const V2: i32 = 2; 786 pub const V3: i32 = 3; 787 pub const V4: i32 = 4; 788 } 789 790 #[cfg(test)] 791 mod test_i64 { 792 pub const V1: i64 = 1; 793 pub const V2: i64 = 2; 794 pub const V3: i64 = 3; 795 pub const V4: i64 = 4; 796 } 797 798 #[cfg(test)] 799 mod test_u8 { 800 pub const V1: u8 = 1; 801 pub const V2: u8 = 2; 802 pub const V3: u8 = 3; 803 pub const V4: u8 = 4; 804 } 805 806 #[cfg(test)] 807 mod test_u16 { 808 pub const V1: u16 = 1; 809 pub const V2: u16 = 2; 810 pub const V3: u16 = 3; 811 pub const V4: u16 = 4; 812 } 813 814 #[cfg(test)] 815 mod test_u32 { 816 pub const V1: u32 = 1; 817 pub const V2: u32 = 2; 818 pub const V3: u32 = 3; 819 pub const V4: u32 = 4; 820 } 821 822 #[cfg(test)] 823 mod test_u64 { 824 pub const V1: u64 = 1; 825 pub const V2: u64 = 2; 826 pub const V3: u64 = 3; 827 pub const V4: u64 = 4; 828 } 829 830 #[cfg(test)] 831 mod test_float { 832 pub const SX0: &str = "[]"; 833 pub const SX1: &str = "[1.0]"; 834 pub const SX2: &str = "[1.0,2.0]"; 835 pub const SX3: &str = "[1.0,2.0,3.0]"; 836 pub const SX4: &str = "[1.0,2.0,3.0,4.0]"; 837 pub const SX5: &str = "[1.0,2.0,3.0,4.0,5.0]"; 838 pub const ST0: &str = "{}"; 839 } 840 841 #[cfg(test)] 842 mod test_int { 843 pub const SX0: &str = "[]"; 844 pub const SX1: &str = "[1]"; 845 pub const SX2: &str = "[1,2]"; 846 pub const SX3: &str = "[1,2,3]"; 847 pub const SX4: &str = "[1,2,3,4]"; 848 pub const SX5: &str = "[1,2,3,4,5]"; 849 pub const ST0: &str = "{}"; 850 } 851 852 #[cfg(test)] 853 mod test_bool_mask { 854 pub const SX0: &str = "[]"; 855 pub const SX1: &str = "[true]"; 856 pub const SX2: &str = "[true,true]"; 857 pub const SX3: &str = "[true,true,true]"; 858 pub const SX4: &str = "[true,true,true,true]"; 859 pub const SX5: &str = "[true,true,true,true,true]"; 860 pub const ST0: &str = "{}"; 861 pub const V1: bool = true; 862 pub const V2: bool = true; 863 pub const V3: bool = true; 864 pub const V4: bool = true; 865 } 866 867 mod bool { 868 #[cfg(test)] 869 use super::test_bool_mask::*; 870 use crate::{BVec2, BVec3, BVec4}; 871 #[cfg(not(feature = "scalar-math"))] 872 use crate::{BVec3A, BVec4A}; 873 use core::fmt; 874 use serde::{ 875 de::{self, Deserialize, Deserializer, SeqAccess, Visitor}, 876 ser::{Serialize, SerializeTupleStruct, Serializer}, 877 }; 878 879 impl_serde_vec2!(bool, BVec2); 880 impl_serde_vec3!(bool, BVec3); 881 impl_serde_vec4!(bool, BVec4); 882 883 #[cfg(not(feature = "scalar-math"))] 884 impl Serialize for BVec3A { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,885 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 886 where 887 S: Serializer, 888 { 889 let mut state = serializer.serialize_tuple_struct("BVec3A", 3)?; 890 let a: [bool; 3] = (*self).into(); 891 state.serialize_field(&a[0])?; 892 state.serialize_field(&a[1])?; 893 state.serialize_field(&a[2])?; 894 state.end() 895 } 896 } 897 898 #[cfg(not(feature = "scalar-math"))] 899 impl<'de> Deserialize<'de> for BVec3A { deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,900 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 901 where 902 D: Deserializer<'de>, 903 { 904 struct Vec3Visitor; 905 906 impl<'de> Visitor<'de> for Vec3Visitor { 907 type Value = BVec3A; 908 909 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 910 formatter.write_str(concat!("a sequence of 3 ", stringify!($t), "values")) 911 } 912 913 fn visit_seq<V>(self, mut seq: V) -> Result<BVec3A, V::Error> 914 where 915 V: SeqAccess<'de>, 916 { 917 let x = seq 918 .next_element()? 919 .ok_or_else(|| de::Error::invalid_length(0, &self))?; 920 let y = seq 921 .next_element()? 922 .ok_or_else(|| de::Error::invalid_length(1, &self))?; 923 let z = seq 924 .next_element()? 925 .ok_or_else(|| de::Error::invalid_length(2, &self))?; 926 Ok(BVec3A::new(x, y, z)) 927 } 928 } 929 930 deserializer.deserialize_tuple_struct(stringify!($vec3), 3, Vec3Visitor) 931 } 932 } 933 934 #[cfg(not(feature = "scalar-math"))] 935 #[test] test_bvec3a_serde()936 fn test_bvec3a_serde() { 937 let a = BVec3A::new(V1, V2, V3); 938 let serialized = serde_json::to_string(&a).unwrap(); 939 assert_eq!(SX3, serialized); 940 let deserialized = serde_json::from_str(&serialized).unwrap(); 941 assert_eq!(a, deserialized); 942 let deserialized = serde_json::from_str::<BVec3A>(SX0); 943 assert!(deserialized.is_err()); 944 let deserialized = serde_json::from_str::<BVec3A>(SX1); 945 assert!(deserialized.is_err()); 946 let deserialized = serde_json::from_str::<BVec3A>(SX2); 947 assert!(deserialized.is_err()); 948 let deserialized = serde_json::from_str::<BVec3A>(SX4); 949 assert!(deserialized.is_err()); 950 } 951 952 #[cfg(not(feature = "scalar-math"))] 953 impl Serialize for BVec4A { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,954 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 955 where 956 S: Serializer, 957 { 958 let mut state = serializer.serialize_tuple_struct(stringify!(BVec4A), 4)?; 959 let a: [bool; 4] = (*self).into(); 960 state.serialize_field(&a[0])?; 961 state.serialize_field(&a[1])?; 962 state.serialize_field(&a[2])?; 963 state.serialize_field(&a[2])?; 964 state.end() 965 } 966 } 967 968 #[cfg(not(feature = "scalar-math"))] 969 impl<'de> Deserialize<'de> for BVec4A { deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,970 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 971 where 972 D: Deserializer<'de>, 973 { 974 struct Vec4Visitor; 975 976 impl<'de> Visitor<'de> for Vec4Visitor { 977 type Value = BVec4A; 978 979 fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { 980 formatter.write_str(concat!("a sequence of 4 ", stringify!($t), "values")) 981 } 982 983 fn visit_seq<V>(self, mut seq: V) -> Result<BVec4A, V::Error> 984 where 985 V: SeqAccess<'de>, 986 { 987 let x = seq 988 .next_element()? 989 .ok_or_else(|| de::Error::invalid_length(0, &self))?; 990 let y = seq 991 .next_element()? 992 .ok_or_else(|| de::Error::invalid_length(1, &self))?; 993 let z = seq 994 .next_element()? 995 .ok_or_else(|| de::Error::invalid_length(2, &self))?; 996 let w = seq 997 .next_element()? 998 .ok_or_else(|| de::Error::invalid_length(3, &self))?; 999 Ok(BVec4A::new(x, y, z, w)) 1000 } 1001 } 1002 1003 deserializer.deserialize_tuple_struct(stringify!(BVec4A), 4, Vec4Visitor) 1004 } 1005 } 1006 1007 #[cfg(not(feature = "scalar-math"))] 1008 #[test] test_bvec4a_serde()1009 fn test_bvec4a_serde() { 1010 let a = BVec4A::new(V1, V2, V3, V4); 1011 let serialized = serde_json::to_string(&a).unwrap(); 1012 assert_eq!(SX4, serialized); 1013 let deserialized = serde_json::from_str(&serialized).unwrap(); 1014 assert_eq!(a, deserialized); 1015 let deserialized = serde_json::from_str::<BVec4A>(SX0); 1016 assert!(deserialized.is_err()); 1017 let deserialized = serde_json::from_str::<BVec4A>(SX1); 1018 assert!(deserialized.is_err()); 1019 let deserialized = serde_json::from_str::<BVec4A>(SX2); 1020 assert!(deserialized.is_err()); 1021 let deserialized = serde_json::from_str::<BVec4A>(SX3); 1022 assert!(deserialized.is_err()); 1023 let deserialized = serde_json::from_str::<BVec4A>(SX5); 1024 assert!(deserialized.is_err()); 1025 } 1026 } 1027 1028 mod f32 { 1029 #[cfg(test)] 1030 use super::test_f32::*; 1031 #[cfg(test)] 1032 use super::test_float::*; 1033 use crate::{Affine2, Affine3A, Mat2, Mat3, Mat3A, Mat4, Quat, Vec2, Vec3, Vec3A, Vec4}; 1034 use core::fmt; 1035 use serde::{ 1036 de::{self, Deserialize, Deserializer, SeqAccess, Visitor}, 1037 ser::{Serialize, SerializeTupleStruct, Serializer}, 1038 }; 1039 1040 impl_serde_float_types!(f32, Affine2, Affine3A, Mat2, Mat3, Mat4, Quat, Vec2, Vec3, Vec4); 1041 impl_serde_mat3!(f32, Mat3A, test_mat3a_serde); 1042 impl_serde_vec3!(f32, Vec3A, test_vec3a_serde); 1043 } 1044 1045 mod f64 { 1046 #[cfg(test)] 1047 use super::test_f64::*; 1048 #[cfg(test)] 1049 use super::test_float::*; 1050 use crate::{DAffine2, DAffine3, DMat2, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4}; 1051 use core::fmt; 1052 use serde::{ 1053 de::{self, Deserialize, Deserializer, SeqAccess, Visitor}, 1054 ser::{Serialize, SerializeTupleStruct, Serializer}, 1055 }; 1056 1057 impl_serde_float_types!( 1058 f64, DAffine2, DAffine3, DMat2, DMat3, DMat4, DQuat, DVec2, DVec3, DVec4 1059 ); 1060 } 1061 1062 mod i8 { 1063 #[cfg(test)] 1064 use super::test_i8::*; 1065 #[cfg(test)] 1066 use super::test_int::*; 1067 use crate::{I8Vec2, I8Vec3, I8Vec4}; 1068 use core::fmt; 1069 use serde::{ 1070 de::{self, Deserialize, Deserializer, SeqAccess, Visitor}, 1071 ser::{Serialize, SerializeTupleStruct, Serializer}, 1072 }; 1073 1074 impl_serde_vec_types!(i8, I8Vec2, I8Vec3, I8Vec4); 1075 } 1076 1077 mod i16 { 1078 #[cfg(test)] 1079 use super::test_i16::*; 1080 #[cfg(test)] 1081 use super::test_int::*; 1082 use crate::{I16Vec2, I16Vec3, I16Vec4}; 1083 use core::fmt; 1084 use serde::{ 1085 de::{self, Deserialize, Deserializer, SeqAccess, Visitor}, 1086 ser::{Serialize, SerializeTupleStruct, Serializer}, 1087 }; 1088 1089 impl_serde_vec_types!(i16, I16Vec2, I16Vec3, I16Vec4); 1090 } 1091 1092 mod i32 { 1093 #[cfg(test)] 1094 use super::test_i32::*; 1095 #[cfg(test)] 1096 use super::test_int::*; 1097 use crate::{IVec2, IVec3, IVec4}; 1098 use core::fmt; 1099 use serde::{ 1100 de::{self, Deserialize, Deserializer, SeqAccess, Visitor}, 1101 ser::{Serialize, SerializeTupleStruct, Serializer}, 1102 }; 1103 1104 impl_serde_vec_types!(i32, IVec2, IVec3, IVec4); 1105 } 1106 1107 mod i64 { 1108 #[cfg(test)] 1109 use super::test_i64::*; 1110 #[cfg(test)] 1111 use super::test_int::*; 1112 use crate::{I64Vec2, I64Vec3, I64Vec4}; 1113 use core::fmt; 1114 use serde::{ 1115 de::{self, Deserialize, Deserializer, SeqAccess, Visitor}, 1116 ser::{Serialize, SerializeTupleStruct, Serializer}, 1117 }; 1118 1119 impl_serde_vec_types!(i64, I64Vec2, I64Vec3, I64Vec4); 1120 } 1121 1122 mod u8 { 1123 #[cfg(test)] 1124 use super::test_int::*; 1125 #[cfg(test)] 1126 use super::test_u8::*; 1127 use crate::{U8Vec2, U8Vec3, U8Vec4}; 1128 use core::fmt; 1129 use serde::{ 1130 de::{self, Deserialize, Deserializer, SeqAccess, Visitor}, 1131 ser::{Serialize, SerializeTupleStruct, Serializer}, 1132 }; 1133 1134 impl_serde_vec_types!(u8, U8Vec2, U8Vec3, U8Vec4); 1135 } 1136 1137 mod u16 { 1138 #[cfg(test)] 1139 use super::test_int::*; 1140 #[cfg(test)] 1141 use super::test_u16::*; 1142 use crate::{U16Vec2, U16Vec3, U16Vec4}; 1143 use core::fmt; 1144 use serde::{ 1145 de::{self, Deserialize, Deserializer, SeqAccess, Visitor}, 1146 ser::{Serialize, SerializeTupleStruct, Serializer}, 1147 }; 1148 1149 impl_serde_vec_types!(u16, U16Vec2, U16Vec3, U16Vec4); 1150 } 1151 1152 mod u32 { 1153 #[cfg(test)] 1154 use super::test_int::*; 1155 #[cfg(test)] 1156 use super::test_u32::*; 1157 use crate::{UVec2, UVec3, UVec4}; 1158 use core::fmt; 1159 use serde::{ 1160 de::{self, Deserialize, Deserializer, SeqAccess, Visitor}, 1161 ser::{Serialize, SerializeTupleStruct, Serializer}, 1162 }; 1163 1164 impl_serde_vec_types!(u32, UVec2, UVec3, UVec4); 1165 } 1166 1167 mod u64 { 1168 #[cfg(test)] 1169 use super::test_int::*; 1170 #[cfg(test)] 1171 use super::test_u64::*; 1172 use crate::{U64Vec2, U64Vec3, U64Vec4}; 1173 use core::fmt; 1174 use serde::{ 1175 de::{self, Deserialize, Deserializer, SeqAccess, Visitor}, 1176 ser::{Serialize, SerializeTupleStruct, Serializer}, 1177 }; 1178 1179 impl_serde_vec_types!(u64, U64Vec2, U64Vec3, U64Vec4); 1180 } 1181 1182 mod euler { 1183 use crate::EulerRot; 1184 1185 impl serde::Serialize for EulerRot { serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>1186 fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { 1187 match *self { 1188 EulerRot::ZYX => { 1189 serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 0u32, "ZYX") 1190 } 1191 EulerRot::ZXY => { 1192 serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 1u32, "ZXY") 1193 } 1194 EulerRot::YXZ => { 1195 serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 2u32, "YXZ") 1196 } 1197 EulerRot::YZX => { 1198 serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 3u32, "YZX") 1199 } 1200 EulerRot::XYZ => { 1201 serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 4u32, "XYZ") 1202 } 1203 EulerRot::XZY => { 1204 serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 5u32, "XZY") 1205 } 1206 EulerRot::ZYZ => { 1207 serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 6u32, "ZYZ") 1208 } 1209 EulerRot::ZXZ => { 1210 serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 7u32, "ZXZ") 1211 } 1212 EulerRot::YXY => { 1213 serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 8u32, "YXY") 1214 } 1215 EulerRot::YZY => { 1216 serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 9u32, "YZY") 1217 } 1218 EulerRot::XYX => { 1219 serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 10u32, "XYX") 1220 } 1221 EulerRot::XZX => { 1222 serde::Serializer::serialize_unit_variant(serializer, "EulerRot", 11u32, "XZX") 1223 } 1224 EulerRot::ZYXEx => serde::Serializer::serialize_unit_variant( 1225 serializer, "EulerRot", 12u32, "ZYXEx", 1226 ), 1227 EulerRot::ZXYEx => serde::Serializer::serialize_unit_variant( 1228 serializer, "EulerRot", 13u32, "ZXYEx", 1229 ), 1230 EulerRot::YXZEx => serde::Serializer::serialize_unit_variant( 1231 serializer, "EulerRot", 14u32, "YXZEx", 1232 ), 1233 EulerRot::YZXEx => serde::Serializer::serialize_unit_variant( 1234 serializer, "EulerRot", 15u32, "YZXEx", 1235 ), 1236 EulerRot::XYZEx => serde::Serializer::serialize_unit_variant( 1237 serializer, "EulerRot", 16u32, "XYZEx", 1238 ), 1239 EulerRot::XZYEx => serde::Serializer::serialize_unit_variant( 1240 serializer, "EulerRot", 17u32, "XZYEx", 1241 ), 1242 EulerRot::ZYZEx => serde::Serializer::serialize_unit_variant( 1243 serializer, "EulerRot", 18u32, "ZYZEx", 1244 ), 1245 EulerRot::ZXZEx => serde::Serializer::serialize_unit_variant( 1246 serializer, "EulerRot", 19u32, "ZXZEx", 1247 ), 1248 EulerRot::YXYEx => serde::Serializer::serialize_unit_variant( 1249 serializer, "EulerRot", 20u32, "YXYEx", 1250 ), 1251 EulerRot::YZYEx => serde::Serializer::serialize_unit_variant( 1252 serializer, "EulerRot", 21u32, "YZYEx", 1253 ), 1254 EulerRot::XYXEx => serde::Serializer::serialize_unit_variant( 1255 serializer, "EulerRot", 22u32, "XYXEx", 1256 ), 1257 EulerRot::XZXEx => serde::Serializer::serialize_unit_variant( 1258 serializer, "EulerRot", 23u32, "XZXEx", 1259 ), 1260 } 1261 } 1262 } 1263 1264 impl<'de> serde::Deserialize<'de> for EulerRot { deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: serde::Deserializer<'de>,1265 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 1266 where 1267 D: serde::Deserializer<'de>, 1268 { 1269 #[allow(clippy::upper_case_acronyms)] 1270 enum Field { 1271 ZYX, 1272 ZXY, 1273 YXZ, 1274 YZX, 1275 XYZ, 1276 XZY, 1277 ZYZ, 1278 ZXZ, 1279 YXY, 1280 YZY, 1281 XYX, 1282 XZX, 1283 ZYXEx, 1284 ZXYEx, 1285 YXZEx, 1286 YZXEx, 1287 XYZEx, 1288 XZYEx, 1289 ZYZEx, 1290 ZXZEx, 1291 YXYEx, 1292 YZYEx, 1293 XYXEx, 1294 XZXEx, 1295 } 1296 struct FieldVisitor; 1297 1298 impl serde::de::Visitor<'_> for FieldVisitor { 1299 type Value = Field; 1300 fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { 1301 core::fmt::Formatter::write_str(formatter, "a variant identifier") 1302 } 1303 fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E> 1304 where 1305 E: serde::de::Error, 1306 { 1307 match value { 1308 0u64 => Ok(Field::ZYX), 1309 1u64 => Ok(Field::ZXY), 1310 2u64 => Ok(Field::YXZ), 1311 3u64 => Ok(Field::YZX), 1312 4u64 => Ok(Field::XYZ), 1313 5u64 => Ok(Field::XZY), 1314 6u64 => Ok(Field::ZYZ), 1315 7u64 => Ok(Field::ZXZ), 1316 8u64 => Ok(Field::YXY), 1317 9u64 => Ok(Field::YZY), 1318 10u64 => Ok(Field::XYX), 1319 11u64 => Ok(Field::XZX), 1320 1321 12u64 => Ok(Field::ZYXEx), 1322 13u64 => Ok(Field::ZXYEx), 1323 14u64 => Ok(Field::YXZEx), 1324 15u64 => Ok(Field::YZXEx), 1325 16u64 => Ok(Field::XYZEx), 1326 17u64 => Ok(Field::XZYEx), 1327 18u64 => Ok(Field::ZYZEx), 1328 19u64 => Ok(Field::ZXZEx), 1329 20u64 => Ok(Field::YXYEx), 1330 21u64 => Ok(Field::YZYEx), 1331 22u64 => Ok(Field::XYXEx), 1332 23u64 => Ok(Field::XZXEx), 1333 _ => Err(serde::de::Error::invalid_value( 1334 serde::de::Unexpected::Unsigned(value), 1335 &"variant index 0 <= i < 24", 1336 )), 1337 } 1338 } 1339 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> 1340 where 1341 E: serde::de::Error, 1342 { 1343 match value { 1344 "ZYX" => Ok(Field::ZYX), 1345 "ZXY" => Ok(Field::ZXY), 1346 "YXZ" => Ok(Field::YXZ), 1347 "YZX" => Ok(Field::YZX), 1348 "XYZ" => Ok(Field::XYZ), 1349 "XZY" => Ok(Field::XZY), 1350 "ZYZ" => Ok(Field::ZYZ), 1351 "ZXZ" => Ok(Field::ZXZ), 1352 "YXY" => Ok(Field::YXY), 1353 "YZY" => Ok(Field::YZY), 1354 "XYX" => Ok(Field::XYX), 1355 "XZX" => Ok(Field::XZX), 1356 "ZYXEx" => Ok(Field::ZYXEx), 1357 "ZXYEx" => Ok(Field::ZXYEx), 1358 "YXZEx" => Ok(Field::YXZEx), 1359 "YZXEx" => Ok(Field::YZXEx), 1360 "XYZEx" => Ok(Field::XYZEx), 1361 "XZYEx" => Ok(Field::XZYEx), 1362 "ZYZEx" => Ok(Field::ZYZEx), 1363 "ZXZEx" => Ok(Field::ZXZEx), 1364 "YXYEx" => Ok(Field::YXYEx), 1365 "YZYEx" => Ok(Field::YZYEx), 1366 "XYXEx" => Ok(Field::XYXEx), 1367 "XZXEx" => Ok(Field::XZXEx), 1368 _ => Err(serde::de::Error::unknown_variant(value, VARIANTS)), 1369 } 1370 } 1371 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E> 1372 where 1373 E: serde::de::Error, 1374 { 1375 match value { 1376 b"ZYX" => Ok(Field::ZYX), 1377 b"ZXY" => Ok(Field::ZXY), 1378 b"YXZ" => Ok(Field::YXZ), 1379 b"YZX" => Ok(Field::YZX), 1380 b"XYZ" => Ok(Field::XYZ), 1381 b"XZY" => Ok(Field::XZY), 1382 b"ZYZ" => Ok(Field::ZYZ), 1383 b"ZXZ" => Ok(Field::ZXZ), 1384 b"YXY" => Ok(Field::YXY), 1385 b"YZY" => Ok(Field::YZY), 1386 b"XYX" => Ok(Field::XYX), 1387 b"XZX" => Ok(Field::XZX), 1388 b"ZYXEx" => Ok(Field::ZYXEx), 1389 b"ZXYEx" => Ok(Field::ZXYEx), 1390 b"YXZEx" => Ok(Field::YXZEx), 1391 b"YZXEx" => Ok(Field::YZXEx), 1392 b"XYZEx" => Ok(Field::XYZEx), 1393 b"XZYEx" => Ok(Field::XZYEx), 1394 b"ZYZEx" => Ok(Field::ZYZEx), 1395 b"ZXZEx" => Ok(Field::ZXZEx), 1396 b"YXYEx" => Ok(Field::YXYEx), 1397 b"YZYEx" => Ok(Field::YZYEx), 1398 b"XYXEx" => Ok(Field::XYXEx), 1399 b"XZXEx" => Ok(Field::XZXEx), 1400 _ => { 1401 #[cfg(feature = "std")] 1402 let value = &String::from_utf8_lossy(value); 1403 #[cfg(not(feature = "std"))] 1404 let value = 1405 core::str::from_utf8(value).unwrap_or("\u{fffd}\u{fffd}\u{fffd}"); 1406 Err(serde::de::Error::unknown_variant(value, VARIANTS)) 1407 } 1408 } 1409 } 1410 } 1411 impl<'de> serde::Deserialize<'de> for Field { 1412 #[inline] 1413 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 1414 where 1415 D: serde::Deserializer<'de>, 1416 { 1417 serde::Deserializer::deserialize_identifier(deserializer, FieldVisitor) 1418 } 1419 } 1420 struct Visitor<'de> { 1421 marker: core::marker::PhantomData<EulerRot>, 1422 lifetime: core::marker::PhantomData<&'de ()>, 1423 } 1424 impl<'de> serde::de::Visitor<'de> for Visitor<'de> { 1425 type Value = EulerRot; 1426 fn expecting( 1427 &self, 1428 __formatter: &mut core::fmt::Formatter<'_>, 1429 ) -> core::fmt::Result { 1430 core::fmt::Formatter::write_str(__formatter, "an EulerRot enum") 1431 } 1432 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error> 1433 where 1434 A: serde::de::EnumAccess<'de>, 1435 { 1436 match serde::de::EnumAccess::variant(data)? { 1437 (Field::ZYX, variant) => { 1438 serde::de::VariantAccess::unit_variant(variant)?; 1439 Ok(EulerRot::ZYX) 1440 } 1441 (Field::ZXY, variant) => { 1442 serde::de::VariantAccess::unit_variant(variant)?; 1443 Ok(EulerRot::ZXY) 1444 } 1445 (Field::YXZ, variant) => { 1446 serde::de::VariantAccess::unit_variant(variant)?; 1447 Ok(EulerRot::YXZ) 1448 } 1449 (Field::YZX, variant) => { 1450 serde::de::VariantAccess::unit_variant(variant)?; 1451 Ok(EulerRot::YZX) 1452 } 1453 (Field::XYZ, variant) => { 1454 serde::de::VariantAccess::unit_variant(variant)?; 1455 Ok(EulerRot::XYZ) 1456 } 1457 (Field::XZY, variant) => { 1458 serde::de::VariantAccess::unit_variant(variant)?; 1459 Ok(EulerRot::XZY) 1460 } 1461 1462 (Field::ZYZ, variant) => { 1463 serde::de::VariantAccess::unit_variant(variant)?; 1464 Ok(EulerRot::ZYZ) 1465 } 1466 (Field::ZXZ, variant) => { 1467 serde::de::VariantAccess::unit_variant(variant)?; 1468 Ok(EulerRot::ZXZ) 1469 } 1470 (Field::YXY, variant) => { 1471 serde::de::VariantAccess::unit_variant(variant)?; 1472 Ok(EulerRot::YXY) 1473 } 1474 (Field::YZY, variant) => { 1475 serde::de::VariantAccess::unit_variant(variant)?; 1476 Ok(EulerRot::YZY) 1477 } 1478 (Field::XYX, variant) => { 1479 serde::de::VariantAccess::unit_variant(variant)?; 1480 Ok(EulerRot::XYX) 1481 } 1482 (Field::XZX, variant) => { 1483 serde::de::VariantAccess::unit_variant(variant)?; 1484 Ok(EulerRot::XZX) 1485 } 1486 (Field::ZYXEx, variant) => { 1487 serde::de::VariantAccess::unit_variant(variant)?; 1488 Ok(EulerRot::ZYXEx) 1489 } 1490 (Field::ZXYEx, variant) => { 1491 serde::de::VariantAccess::unit_variant(variant)?; 1492 Ok(EulerRot::ZXYEx) 1493 } 1494 (Field::YXZEx, variant) => { 1495 serde::de::VariantAccess::unit_variant(variant)?; 1496 Ok(EulerRot::YXZEx) 1497 } 1498 (Field::YZXEx, variant) => { 1499 serde::de::VariantAccess::unit_variant(variant)?; 1500 Ok(EulerRot::YZXEx) 1501 } 1502 (Field::XYZEx, variant) => { 1503 serde::de::VariantAccess::unit_variant(variant)?; 1504 Ok(EulerRot::XYZEx) 1505 } 1506 (Field::XZYEx, variant) => { 1507 serde::de::VariantAccess::unit_variant(variant)?; 1508 Ok(EulerRot::XZYEx) 1509 } 1510 (Field::ZYZEx, variant) => { 1511 serde::de::VariantAccess::unit_variant(variant)?; 1512 Ok(EulerRot::ZYZEx) 1513 } 1514 (Field::ZXZEx, variant) => { 1515 serde::de::VariantAccess::unit_variant(variant)?; 1516 Ok(EulerRot::ZXZEx) 1517 } 1518 (Field::YXYEx, variant) => { 1519 serde::de::VariantAccess::unit_variant(variant)?; 1520 Ok(EulerRot::YXYEx) 1521 } 1522 (Field::YZYEx, variant) => { 1523 serde::de::VariantAccess::unit_variant(variant)?; 1524 Ok(EulerRot::YZYEx) 1525 } 1526 (Field::XYXEx, variant) => { 1527 serde::de::VariantAccess::unit_variant(variant)?; 1528 Ok(EulerRot::XYXEx) 1529 } 1530 (Field::XZXEx, variant) => { 1531 serde::de::VariantAccess::unit_variant(variant)?; 1532 Ok(EulerRot::XZXEx) 1533 } 1534 } 1535 } 1536 } 1537 const VARIANTS: &[&str] = &[ 1538 "ZYX", "ZXY", "YXZ", "YZX", "XYZ", "XZY", "ZYZ", "ZXZ", "YXY", "YZY", "XYX", "XZX", 1539 "ZYXEx", "ZXYEx", "YXZEx", "YZXEx", "XYZEx", "XZYEx", "ZYZEx", "ZXZEx", "YXYEx", 1540 "YZYEx", "XYXEx", "XZXEx", 1541 ]; 1542 serde::Deserializer::deserialize_enum( 1543 deserializer, 1544 "EulerRot", 1545 VARIANTS, 1546 Visitor { 1547 marker: core::marker::PhantomData::<EulerRot>, 1548 lifetime: core::marker::PhantomData, 1549 }, 1550 ) 1551 } 1552 } 1553 1554 #[test] test_euler_rot_serde()1555 fn test_euler_rot_serde() { 1556 const PAIRS: [(EulerRot, &str); 24] = [ 1557 (EulerRot::ZYX, "\"ZYX\""), 1558 (EulerRot::ZXY, "\"ZXY\""), 1559 (EulerRot::YXZ, "\"YXZ\""), 1560 (EulerRot::YZX, "\"YZX\""), 1561 (EulerRot::XYZ, "\"XYZ\""), 1562 (EulerRot::XZY, "\"XZY\""), 1563 (EulerRot::ZYZ, "\"ZYZ\""), 1564 (EulerRot::ZXZ, "\"ZXZ\""), 1565 (EulerRot::YXY, "\"YXY\""), 1566 (EulerRot::YZY, "\"YZY\""), 1567 (EulerRot::XYX, "\"XYX\""), 1568 (EulerRot::XZX, "\"XZX\""), 1569 (EulerRot::ZYXEx, "\"ZYXEx\""), 1570 (EulerRot::ZXYEx, "\"ZXYEx\""), 1571 (EulerRot::YXZEx, "\"YXZEx\""), 1572 (EulerRot::YZXEx, "\"YZXEx\""), 1573 (EulerRot::XYZEx, "\"XYZEx\""), 1574 (EulerRot::XZYEx, "\"XZYEx\""), 1575 (EulerRot::ZYZEx, "\"ZYZEx\""), 1576 (EulerRot::ZXZEx, "\"ZXZEx\""), 1577 (EulerRot::YXYEx, "\"YXYEx\""), 1578 (EulerRot::YZYEx, "\"YZYEx\""), 1579 (EulerRot::XYXEx, "\"XYXEx\""), 1580 (EulerRot::XZXEx, "\"XZXEx\""), 1581 ]; 1582 for (enum_value, enum_string) in PAIRS { 1583 let serialized = serde_json::to_string(&enum_value).unwrap(); 1584 assert_eq!(enum_string, serialized); 1585 let deserialized = serde_json::from_str(&serialized).unwrap(); 1586 assert_eq!(enum_value, deserialized); 1587 } 1588 } 1589 } 1590