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