1use super::class_requires::*;
2use super::*;
3#[allow(non_upper_case_globals, non_snake_case)]
10#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
11#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
12#[derive(educe::Educe)]
13#[educe(Debug, Clone, Default, PartialEq)]
14pub struct hkaWaveletCompressedAnimationCompressionParams {
15 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[cfg_attr(feature = "json_schema", schemars(rename = "quantizationBits"))]
31 #[cfg_attr(feature = "serde", serde(rename = "quantizationBits"))]
32 pub m_quantizationBits: u16,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "blockSize"))]
38 #[cfg_attr(feature = "serde", serde(rename = "blockSize"))]
39 pub m_blockSize: u16,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "preserve"))]
45 #[cfg_attr(feature = "serde", serde(rename = "preserve"))]
46 pub m_preserve: u16,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "truncProp"))]
52 #[cfg_attr(feature = "serde", serde(rename = "truncProp"))]
53 pub m_truncProp: f32,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "useOldStyleTruncation"))]
59 #[cfg_attr(feature = "serde", serde(rename = "useOldStyleTruncation"))]
60 pub m_useOldStyleTruncation: bool,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "absolutePositionTolerance"))]
66 #[cfg_attr(feature = "serde", serde(rename = "absolutePositionTolerance"))]
67 pub m_absolutePositionTolerance: f32,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "relativePositionTolerance"))]
73 #[cfg_attr(feature = "serde", serde(rename = "relativePositionTolerance"))]
74 pub m_relativePositionTolerance: f32,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "rotationTolerance"))]
80 #[cfg_attr(feature = "serde", serde(rename = "rotationTolerance"))]
81 pub m_rotationTolerance: f32,
82 #[cfg_attr(feature = "json_schema", schemars(rename = "scaleTolerance"))]
87 #[cfg_attr(feature = "serde", serde(rename = "scaleTolerance"))]
88 pub m_scaleTolerance: f32,
89 #[cfg_attr(feature = "json_schema", schemars(rename = "absoluteFloatTolerance"))]
94 #[cfg_attr(feature = "serde", serde(rename = "absoluteFloatTolerance"))]
95 pub m_absoluteFloatTolerance: f32,
96}
97const _: () = {
98 use havok_serde as _serde;
99 impl _serde::HavokClass for hkaWaveletCompressedAnimationCompressionParams {
100 #[inline]
101 fn name(&self) -> &'static str {
102 "hkaWaveletCompressedAnimationCompressionParams"
103 }
104 #[inline]
105 fn signature(&self) -> _serde::__private::Signature {
106 _serde::__private::Signature::new(0x27c6cafa)
107 }
108 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
109 fn deps_indexes(&self) -> Vec<usize> {
110 let mut v = Vec::new();
111 v
112 }
113 }
114 impl _serde::Serialize for hkaWaveletCompressedAnimationCompressionParams {
115 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
116 where
117 S: _serde::ser::Serializer,
118 {
119 let class_meta = self
120 .__ptr
121 .map(|name| (name, _serde::__private::Signature::new(0x27c6cafa)));
122 let mut serializer = __serializer
123 .serialize_struct(
124 "hkaWaveletCompressedAnimationCompressionParams",
125 class_meta,
126 (36u64, 36u64),
127 )?;
128 serializer.serialize_field("quantizationBits", &self.m_quantizationBits)?;
129 serializer.serialize_field("blockSize", &self.m_blockSize)?;
130 serializer.serialize_field("preserve", &self.m_preserve)?;
131 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
132 serializer.serialize_field("truncProp", &self.m_truncProp)?;
133 serializer
134 .serialize_field(
135 "useOldStyleTruncation",
136 &self.m_useOldStyleTruncation,
137 )?;
138 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
139 serializer
140 .serialize_field(
141 "absolutePositionTolerance",
142 &self.m_absolutePositionTolerance,
143 )?;
144 serializer
145 .serialize_field(
146 "relativePositionTolerance",
147 &self.m_relativePositionTolerance,
148 )?;
149 serializer.serialize_field("rotationTolerance", &self.m_rotationTolerance)?;
150 serializer.serialize_field("scaleTolerance", &self.m_scaleTolerance)?;
151 serializer
152 .serialize_field(
153 "absoluteFloatTolerance",
154 &self.m_absoluteFloatTolerance,
155 )?;
156 serializer.end()
157 }
158 }
159};
160#[doc(hidden)]
161#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
162const _: () = {
163 use havok_serde as _serde;
164 #[automatically_derived]
165 impl<'de> _serde::Deserialize<'de>
166 for hkaWaveletCompressedAnimationCompressionParams {
167 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
168 where
169 __D: _serde::Deserializer<'de>,
170 {
171 #[allow(non_camel_case_types)]
172 enum __Field {
173 m_quantizationBits,
174 m_blockSize,
175 m_preserve,
176 m_truncProp,
177 m_useOldStyleTruncation,
178 m_absolutePositionTolerance,
179 m_relativePositionTolerance,
180 m_rotationTolerance,
181 m_scaleTolerance,
182 m_absoluteFloatTolerance,
183 __ignore,
184 }
185 struct __FieldVisitor;
186 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
187 type Value = __Field;
188 fn expecting(
189 &self,
190 __formatter: &mut core::fmt::Formatter,
191 ) -> core::fmt::Result {
192 core::fmt::Formatter::write_str(__formatter, "field identifier")
193 }
194 #[allow(clippy::match_single_binding)]
196 #[allow(clippy::reversed_empty_ranges)]
197 #[allow(clippy::single_match)]
198 fn visit_key<__E>(
199 self,
200 __value: &str,
201 ) -> core::result::Result<Self::Value, __E>
202 where
203 __E: _serde::de::Error,
204 {
205 match __value {
206 "quantizationBits" => Ok(__Field::m_quantizationBits),
207 "blockSize" => Ok(__Field::m_blockSize),
208 "preserve" => Ok(__Field::m_preserve),
209 "truncProp" => Ok(__Field::m_truncProp),
210 "useOldStyleTruncation" => Ok(__Field::m_useOldStyleTruncation),
211 "absolutePositionTolerance" => {
212 Ok(__Field::m_absolutePositionTolerance)
213 }
214 "relativePositionTolerance" => {
215 Ok(__Field::m_relativePositionTolerance)
216 }
217 "rotationTolerance" => Ok(__Field::m_rotationTolerance),
218 "scaleTolerance" => Ok(__Field::m_scaleTolerance),
219 "absoluteFloatTolerance" => Ok(__Field::m_absoluteFloatTolerance),
220 _ => Ok(__Field::__ignore),
221 }
222 }
223 }
224 impl<'de> _serde::Deserialize<'de> for __Field {
225 #[inline]
226 fn deserialize<__D>(
227 __deserializer: __D,
228 ) -> core::result::Result<Self, __D::Error>
229 where
230 __D: _serde::Deserializer<'de>,
231 {
232 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
233 }
234 }
235 struct __hkaWaveletCompressedAnimationCompressionParamsVisitor<'de> {
236 marker: _serde::__private::PhantomData<
237 hkaWaveletCompressedAnimationCompressionParams,
238 >,
239 lifetime: _serde::__private::PhantomData<&'de ()>,
240 }
241 #[allow(clippy::match_single_binding)]
242 #[allow(clippy::reversed_empty_ranges)]
243 #[allow(clippy::single_match)]
244 impl<'de> _serde::de::Visitor<'de>
245 for __hkaWaveletCompressedAnimationCompressionParamsVisitor<'de> {
246 type Value = hkaWaveletCompressedAnimationCompressionParams;
247 fn expecting(
248 &self,
249 __formatter: &mut core::fmt::Formatter,
250 ) -> core::fmt::Result {
251 core::fmt::Formatter::write_str(
252 __formatter,
253 "struct hkaWaveletCompressedAnimationCompressionParams",
254 )
255 }
256 fn visit_struct_for_bytes<__A>(
257 self,
258 mut __map: __A,
259 ) -> _serde::__private::Result<Self::Value, __A::Error>
260 where
261 __A: _serde::de::MapAccess<'de>,
262 {
263 let __ptr = __A::class_ptr(&mut __map);
264 let mut m_quantizationBits: _serde::__private::Option<u16> = _serde::__private::None;
265 let mut m_blockSize: _serde::__private::Option<u16> = _serde::__private::None;
266 let mut m_preserve: _serde::__private::Option<u16> = _serde::__private::None;
267 let mut m_truncProp: _serde::__private::Option<f32> = _serde::__private::None;
268 let mut m_useOldStyleTruncation: _serde::__private::Option<bool> = _serde::__private::None;
269 let mut m_absolutePositionTolerance: _serde::__private::Option<
270 f32,
271 > = _serde::__private::None;
272 let mut m_relativePositionTolerance: _serde::__private::Option<
273 f32,
274 > = _serde::__private::None;
275 let mut m_rotationTolerance: _serde::__private::Option<f32> = _serde::__private::None;
276 let mut m_scaleTolerance: _serde::__private::Option<f32> = _serde::__private::None;
277 let mut m_absoluteFloatTolerance: _serde::__private::Option<f32> = _serde::__private::None;
278 for i in 0..10usize {
279 match i {
280 0usize => {
281 if _serde::__private::Option::is_some(&m_quantizationBits) {
282 return _serde::__private::Err(
283 <__A::Error as _serde::de::Error>::duplicate_field(
284 "quantizationBits",
285 ),
286 );
287 }
288 m_quantizationBits = _serde::__private::Some(
289 match __A::next_value::<u16>(&mut __map) {
290 _serde::__private::Ok(__val) => __val,
291 _serde::__private::Err(__err) => {
292 return _serde::__private::Err(__err);
293 }
294 },
295 );
296 }
297 1usize => {
298 if _serde::__private::Option::is_some(&m_blockSize) {
299 return _serde::__private::Err(
300 <__A::Error as _serde::de::Error>::duplicate_field(
301 "blockSize",
302 ),
303 );
304 }
305 m_blockSize = _serde::__private::Some(
306 match __A::next_value::<u16>(&mut __map) {
307 _serde::__private::Ok(__val) => __val,
308 _serde::__private::Err(__err) => {
309 return _serde::__private::Err(__err);
310 }
311 },
312 );
313 }
314 2usize => {
315 if _serde::__private::Option::is_some(&m_preserve) {
316 return _serde::__private::Err(
317 <__A::Error as _serde::de::Error>::duplicate_field(
318 "preserve",
319 ),
320 );
321 }
322 m_preserve = _serde::__private::Some(
323 match __A::next_value::<u16>(&mut __map) {
324 _serde::__private::Ok(__val) => __val,
325 _serde::__private::Err(__err) => {
326 return _serde::__private::Err(__err);
327 }
328 },
329 );
330 }
331 3usize => {
332 if _serde::__private::Option::is_some(&m_truncProp) {
333 return _serde::__private::Err(
334 <__A::Error as _serde::de::Error>::duplicate_field(
335 "truncProp",
336 ),
337 );
338 }
339 __A::pad(&mut __map, 2usize, 2usize)?;
340 m_truncProp = _serde::__private::Some(
341 match __A::next_value::<f32>(&mut __map) {
342 _serde::__private::Ok(__val) => __val,
343 _serde::__private::Err(__err) => {
344 return _serde::__private::Err(__err);
345 }
346 },
347 );
348 }
349 4usize => {
350 if _serde::__private::Option::is_some(
351 &m_useOldStyleTruncation,
352 ) {
353 return _serde::__private::Err(
354 <__A::Error as _serde::de::Error>::duplicate_field(
355 "useOldStyleTruncation",
356 ),
357 );
358 }
359 m_useOldStyleTruncation = _serde::__private::Some(
360 match __A::next_value::<bool>(&mut __map) {
361 _serde::__private::Ok(__val) => __val,
362 _serde::__private::Err(__err) => {
363 return _serde::__private::Err(__err);
364 }
365 },
366 );
367 }
368 5usize => {
369 if _serde::__private::Option::is_some(
370 &m_absolutePositionTolerance,
371 ) {
372 return _serde::__private::Err(
373 <__A::Error as _serde::de::Error>::duplicate_field(
374 "absolutePositionTolerance",
375 ),
376 );
377 }
378 __A::pad(&mut __map, 3usize, 3usize)?;
379 m_absolutePositionTolerance = _serde::__private::Some(
380 match __A::next_value::<f32>(&mut __map) {
381 _serde::__private::Ok(__val) => __val,
382 _serde::__private::Err(__err) => {
383 return _serde::__private::Err(__err);
384 }
385 },
386 );
387 }
388 6usize => {
389 if _serde::__private::Option::is_some(
390 &m_relativePositionTolerance,
391 ) {
392 return _serde::__private::Err(
393 <__A::Error as _serde::de::Error>::duplicate_field(
394 "relativePositionTolerance",
395 ),
396 );
397 }
398 m_relativePositionTolerance = _serde::__private::Some(
399 match __A::next_value::<f32>(&mut __map) {
400 _serde::__private::Ok(__val) => __val,
401 _serde::__private::Err(__err) => {
402 return _serde::__private::Err(__err);
403 }
404 },
405 );
406 }
407 7usize => {
408 if _serde::__private::Option::is_some(
409 &m_rotationTolerance,
410 ) {
411 return _serde::__private::Err(
412 <__A::Error as _serde::de::Error>::duplicate_field(
413 "rotationTolerance",
414 ),
415 );
416 }
417 m_rotationTolerance = _serde::__private::Some(
418 match __A::next_value::<f32>(&mut __map) {
419 _serde::__private::Ok(__val) => __val,
420 _serde::__private::Err(__err) => {
421 return _serde::__private::Err(__err);
422 }
423 },
424 );
425 }
426 8usize => {
427 if _serde::__private::Option::is_some(&m_scaleTolerance) {
428 return _serde::__private::Err(
429 <__A::Error as _serde::de::Error>::duplicate_field(
430 "scaleTolerance",
431 ),
432 );
433 }
434 m_scaleTolerance = _serde::__private::Some(
435 match __A::next_value::<f32>(&mut __map) {
436 _serde::__private::Ok(__val) => __val,
437 _serde::__private::Err(__err) => {
438 return _serde::__private::Err(__err);
439 }
440 },
441 );
442 }
443 9usize => {
444 if _serde::__private::Option::is_some(
445 &m_absoluteFloatTolerance,
446 ) {
447 return _serde::__private::Err(
448 <__A::Error as _serde::de::Error>::duplicate_field(
449 "absoluteFloatTolerance",
450 ),
451 );
452 }
453 m_absoluteFloatTolerance = _serde::__private::Some(
454 match __A::next_value::<f32>(&mut __map) {
455 _serde::__private::Ok(__val) => __val,
456 _serde::__private::Err(__err) => {
457 return _serde::__private::Err(__err);
458 }
459 },
460 );
461 }
462 _ => {}
463 }
464 }
465 let m_quantizationBits = match m_quantizationBits {
466 _serde::__private::Some(__field) => __field,
467 _serde::__private::None => {
468 return _serde::__private::Err(
469 <__A::Error as _serde::de::Error>::missing_field(
470 "quantizationBits",
471 ),
472 );
473 }
474 };
475 let m_blockSize = match m_blockSize {
476 _serde::__private::Some(__field) => __field,
477 _serde::__private::None => {
478 return _serde::__private::Err(
479 <__A::Error as _serde::de::Error>::missing_field(
480 "blockSize",
481 ),
482 );
483 }
484 };
485 let m_preserve = match m_preserve {
486 _serde::__private::Some(__field) => __field,
487 _serde::__private::None => {
488 return _serde::__private::Err(
489 <__A::Error as _serde::de::Error>::missing_field("preserve"),
490 );
491 }
492 };
493 let m_truncProp = match m_truncProp {
494 _serde::__private::Some(__field) => __field,
495 _serde::__private::None => {
496 return _serde::__private::Err(
497 <__A::Error as _serde::de::Error>::missing_field(
498 "truncProp",
499 ),
500 );
501 }
502 };
503 let m_useOldStyleTruncation = match m_useOldStyleTruncation {
504 _serde::__private::Some(__field) => __field,
505 _serde::__private::None => {
506 return _serde::__private::Err(
507 <__A::Error as _serde::de::Error>::missing_field(
508 "useOldStyleTruncation",
509 ),
510 );
511 }
512 };
513 let m_absolutePositionTolerance = match m_absolutePositionTolerance {
514 _serde::__private::Some(__field) => __field,
515 _serde::__private::None => {
516 return _serde::__private::Err(
517 <__A::Error as _serde::de::Error>::missing_field(
518 "absolutePositionTolerance",
519 ),
520 );
521 }
522 };
523 let m_relativePositionTolerance = match m_relativePositionTolerance {
524 _serde::__private::Some(__field) => __field,
525 _serde::__private::None => {
526 return _serde::__private::Err(
527 <__A::Error as _serde::de::Error>::missing_field(
528 "relativePositionTolerance",
529 ),
530 );
531 }
532 };
533 let m_rotationTolerance = match m_rotationTolerance {
534 _serde::__private::Some(__field) => __field,
535 _serde::__private::None => {
536 return _serde::__private::Err(
537 <__A::Error as _serde::de::Error>::missing_field(
538 "rotationTolerance",
539 ),
540 );
541 }
542 };
543 let m_scaleTolerance = match m_scaleTolerance {
544 _serde::__private::Some(__field) => __field,
545 _serde::__private::None => {
546 return _serde::__private::Err(
547 <__A::Error as _serde::de::Error>::missing_field(
548 "scaleTolerance",
549 ),
550 );
551 }
552 };
553 let m_absoluteFloatTolerance = match m_absoluteFloatTolerance {
554 _serde::__private::Some(__field) => __field,
555 _serde::__private::None => {
556 return _serde::__private::Err(
557 <__A::Error as _serde::de::Error>::missing_field(
558 "absoluteFloatTolerance",
559 ),
560 );
561 }
562 };
563 _serde::__private::Ok(hkaWaveletCompressedAnimationCompressionParams {
564 __ptr,
565 m_quantizationBits,
566 m_blockSize,
567 m_preserve,
568 m_truncProp,
569 m_useOldStyleTruncation,
570 m_absolutePositionTolerance,
571 m_relativePositionTolerance,
572 m_rotationTolerance,
573 m_scaleTolerance,
574 m_absoluteFloatTolerance,
575 })
576 }
577 #[allow(clippy::manual_unwrap_or_default)]
578 fn visit_struct<__A>(
579 self,
580 mut __map: __A,
581 ) -> _serde::__private::Result<Self::Value, __A::Error>
582 where
583 __A: _serde::de::MapAccess<'de>,
584 {
585 let mut m_quantizationBits: _serde::__private::Option<u16> = _serde::__private::None;
586 let mut m_blockSize: _serde::__private::Option<u16> = _serde::__private::None;
587 let mut m_preserve: _serde::__private::Option<u16> = _serde::__private::None;
588 let mut m_truncProp: _serde::__private::Option<f32> = _serde::__private::None;
589 let mut m_useOldStyleTruncation: _serde::__private::Option<bool> = _serde::__private::None;
590 let mut m_absolutePositionTolerance: _serde::__private::Option<
591 f32,
592 > = _serde::__private::None;
593 let mut m_relativePositionTolerance: _serde::__private::Option<
594 f32,
595 > = _serde::__private::None;
596 let mut m_rotationTolerance: _serde::__private::Option<f32> = _serde::__private::None;
597 let mut m_scaleTolerance: _serde::__private::Option<f32> = _serde::__private::None;
598 let mut m_absoluteFloatTolerance: _serde::__private::Option<f32> = _serde::__private::None;
599 while let _serde::__private::Some(__key) = {
600 __A::next_key::<__Field>(&mut __map)?
601 } {
602 match __key {
603 __Field::m_quantizationBits => {
604 #[cfg(
605 any(feature = "strict", feature = "ignore_duplicates")
606 )]
607 if _serde::__private::Option::is_some(&m_quantizationBits) {
608 #[cfg(feature = "ignore_duplicates")]
609 {
610 __A::skip_value(&mut __map)?;
611 continue;
612 }
613 #[cfg(feature = "strict")]
614 return _serde::__private::Err(
615 <__A::Error as _serde::de::Error>::duplicate_field(
616 "quantizationBits",
617 ),
618 );
619 }
620 m_quantizationBits = _serde::__private::Some(
621 match __A::next_value::<u16>(&mut __map) {
622 _serde::__private::Ok(__val) => __val,
623 _serde::__private::Err(__err) => {
624 return _serde::__private::Err(__err);
625 }
626 },
627 );
628 }
629 __Field::m_blockSize => {
630 #[cfg(
631 any(feature = "strict", feature = "ignore_duplicates")
632 )]
633 if _serde::__private::Option::is_some(&m_blockSize) {
634 #[cfg(feature = "ignore_duplicates")]
635 {
636 __A::skip_value(&mut __map)?;
637 continue;
638 }
639 #[cfg(feature = "strict")]
640 return _serde::__private::Err(
641 <__A::Error as _serde::de::Error>::duplicate_field(
642 "blockSize",
643 ),
644 );
645 }
646 m_blockSize = _serde::__private::Some(
647 match __A::next_value::<u16>(&mut __map) {
648 _serde::__private::Ok(__val) => __val,
649 _serde::__private::Err(__err) => {
650 return _serde::__private::Err(__err);
651 }
652 },
653 );
654 }
655 __Field::m_preserve => {
656 #[cfg(
657 any(feature = "strict", feature = "ignore_duplicates")
658 )]
659 if _serde::__private::Option::is_some(&m_preserve) {
660 #[cfg(feature = "ignore_duplicates")]
661 {
662 __A::skip_value(&mut __map)?;
663 continue;
664 }
665 #[cfg(feature = "strict")]
666 return _serde::__private::Err(
667 <__A::Error as _serde::de::Error>::duplicate_field(
668 "preserve",
669 ),
670 );
671 }
672 m_preserve = _serde::__private::Some(
673 match __A::next_value::<u16>(&mut __map) {
674 _serde::__private::Ok(__val) => __val,
675 _serde::__private::Err(__err) => {
676 return _serde::__private::Err(__err);
677 }
678 },
679 );
680 }
681 __Field::m_truncProp => {
682 #[cfg(
683 any(feature = "strict", feature = "ignore_duplicates")
684 )]
685 if _serde::__private::Option::is_some(&m_truncProp) {
686 #[cfg(feature = "ignore_duplicates")]
687 {
688 __A::skip_value(&mut __map)?;
689 continue;
690 }
691 #[cfg(feature = "strict")]
692 return _serde::__private::Err(
693 <__A::Error as _serde::de::Error>::duplicate_field(
694 "truncProp",
695 ),
696 );
697 }
698 m_truncProp = _serde::__private::Some(
699 match __A::next_value::<f32>(&mut __map) {
700 _serde::__private::Ok(__val) => __val,
701 _serde::__private::Err(__err) => {
702 return _serde::__private::Err(__err);
703 }
704 },
705 );
706 }
707 __Field::m_useOldStyleTruncation => {
708 #[cfg(
709 any(feature = "strict", feature = "ignore_duplicates")
710 )]
711 if _serde::__private::Option::is_some(
712 &m_useOldStyleTruncation,
713 ) {
714 #[cfg(feature = "ignore_duplicates")]
715 {
716 __A::skip_value(&mut __map)?;
717 continue;
718 }
719 #[cfg(feature = "strict")]
720 return _serde::__private::Err(
721 <__A::Error as _serde::de::Error>::duplicate_field(
722 "useOldStyleTruncation",
723 ),
724 );
725 }
726 m_useOldStyleTruncation = _serde::__private::Some(
727 match __A::next_value::<bool>(&mut __map) {
728 _serde::__private::Ok(__val) => __val,
729 _serde::__private::Err(__err) => {
730 return _serde::__private::Err(__err);
731 }
732 },
733 );
734 }
735 __Field::m_absolutePositionTolerance => {
736 #[cfg(
737 any(feature = "strict", feature = "ignore_duplicates")
738 )]
739 if _serde::__private::Option::is_some(
740 &m_absolutePositionTolerance,
741 ) {
742 #[cfg(feature = "ignore_duplicates")]
743 {
744 __A::skip_value(&mut __map)?;
745 continue;
746 }
747 #[cfg(feature = "strict")]
748 return _serde::__private::Err(
749 <__A::Error as _serde::de::Error>::duplicate_field(
750 "absolutePositionTolerance",
751 ),
752 );
753 }
754 m_absolutePositionTolerance = _serde::__private::Some(
755 match __A::next_value::<f32>(&mut __map) {
756 _serde::__private::Ok(__val) => __val,
757 _serde::__private::Err(__err) => {
758 return _serde::__private::Err(__err);
759 }
760 },
761 );
762 }
763 __Field::m_relativePositionTolerance => {
764 #[cfg(
765 any(feature = "strict", feature = "ignore_duplicates")
766 )]
767 if _serde::__private::Option::is_some(
768 &m_relativePositionTolerance,
769 ) {
770 #[cfg(feature = "ignore_duplicates")]
771 {
772 __A::skip_value(&mut __map)?;
773 continue;
774 }
775 #[cfg(feature = "strict")]
776 return _serde::__private::Err(
777 <__A::Error as _serde::de::Error>::duplicate_field(
778 "relativePositionTolerance",
779 ),
780 );
781 }
782 m_relativePositionTolerance = _serde::__private::Some(
783 match __A::next_value::<f32>(&mut __map) {
784 _serde::__private::Ok(__val) => __val,
785 _serde::__private::Err(__err) => {
786 return _serde::__private::Err(__err);
787 }
788 },
789 );
790 }
791 __Field::m_rotationTolerance => {
792 #[cfg(
793 any(feature = "strict", feature = "ignore_duplicates")
794 )]
795 if _serde::__private::Option::is_some(
796 &m_rotationTolerance,
797 ) {
798 #[cfg(feature = "ignore_duplicates")]
799 {
800 __A::skip_value(&mut __map)?;
801 continue;
802 }
803 #[cfg(feature = "strict")]
804 return _serde::__private::Err(
805 <__A::Error as _serde::de::Error>::duplicate_field(
806 "rotationTolerance",
807 ),
808 );
809 }
810 m_rotationTolerance = _serde::__private::Some(
811 match __A::next_value::<f32>(&mut __map) {
812 _serde::__private::Ok(__val) => __val,
813 _serde::__private::Err(__err) => {
814 return _serde::__private::Err(__err);
815 }
816 },
817 );
818 }
819 __Field::m_scaleTolerance => {
820 #[cfg(
821 any(feature = "strict", feature = "ignore_duplicates")
822 )]
823 if _serde::__private::Option::is_some(&m_scaleTolerance) {
824 #[cfg(feature = "ignore_duplicates")]
825 {
826 __A::skip_value(&mut __map)?;
827 continue;
828 }
829 #[cfg(feature = "strict")]
830 return _serde::__private::Err(
831 <__A::Error as _serde::de::Error>::duplicate_field(
832 "scaleTolerance",
833 ),
834 );
835 }
836 m_scaleTolerance = _serde::__private::Some(
837 match __A::next_value::<f32>(&mut __map) {
838 _serde::__private::Ok(__val) => __val,
839 _serde::__private::Err(__err) => {
840 return _serde::__private::Err(__err);
841 }
842 },
843 );
844 }
845 __Field::m_absoluteFloatTolerance => {
846 #[cfg(
847 any(feature = "strict", feature = "ignore_duplicates")
848 )]
849 if _serde::__private::Option::is_some(
850 &m_absoluteFloatTolerance,
851 ) {
852 #[cfg(feature = "ignore_duplicates")]
853 {
854 __A::skip_value(&mut __map)?;
855 continue;
856 }
857 #[cfg(feature = "strict")]
858 return _serde::__private::Err(
859 <__A::Error as _serde::de::Error>::duplicate_field(
860 "absoluteFloatTolerance",
861 ),
862 );
863 }
864 m_absoluteFloatTolerance = _serde::__private::Some(
865 match __A::next_value::<f32>(&mut __map) {
866 _serde::__private::Ok(__val) => __val,
867 _serde::__private::Err(__err) => {
868 return _serde::__private::Err(__err);
869 }
870 },
871 );
872 }
873 _ => __A::skip_value(&mut __map)?,
874 }
875 }
876 let m_quantizationBits = match m_quantizationBits {
877 _serde::__private::Some(__field) => __field,
878 _serde::__private::None => {
879 #[cfg(feature = "strict")]
880 return _serde::__private::Err(
881 <__A::Error as _serde::de::Error>::missing_field(
882 "quantizationBits",
883 ),
884 );
885 #[cfg(not(feature = "strict"))] Default::default()
886 }
887 };
888 let m_blockSize = match m_blockSize {
889 _serde::__private::Some(__field) => __field,
890 _serde::__private::None => {
891 #[cfg(feature = "strict")]
892 return _serde::__private::Err(
893 <__A::Error as _serde::de::Error>::missing_field(
894 "blockSize",
895 ),
896 );
897 #[cfg(not(feature = "strict"))] Default::default()
898 }
899 };
900 let m_preserve = match m_preserve {
901 _serde::__private::Some(__field) => __field,
902 _serde::__private::None => {
903 #[cfg(feature = "strict")]
904 return _serde::__private::Err(
905 <__A::Error as _serde::de::Error>::missing_field("preserve"),
906 );
907 #[cfg(not(feature = "strict"))] Default::default()
908 }
909 };
910 let m_truncProp = match m_truncProp {
911 _serde::__private::Some(__field) => __field,
912 _serde::__private::None => {
913 #[cfg(feature = "strict")]
914 return _serde::__private::Err(
915 <__A::Error as _serde::de::Error>::missing_field(
916 "truncProp",
917 ),
918 );
919 #[cfg(not(feature = "strict"))] Default::default()
920 }
921 };
922 let m_useOldStyleTruncation = match m_useOldStyleTruncation {
923 _serde::__private::Some(__field) => __field,
924 _serde::__private::None => {
925 #[cfg(feature = "strict")]
926 return _serde::__private::Err(
927 <__A::Error as _serde::de::Error>::missing_field(
928 "useOldStyleTruncation",
929 ),
930 );
931 #[cfg(not(feature = "strict"))] Default::default()
932 }
933 };
934 let m_absolutePositionTolerance = match m_absolutePositionTolerance {
935 _serde::__private::Some(__field) => __field,
936 _serde::__private::None => {
937 #[cfg(feature = "strict")]
938 return _serde::__private::Err(
939 <__A::Error as _serde::de::Error>::missing_field(
940 "absolutePositionTolerance",
941 ),
942 );
943 #[cfg(not(feature = "strict"))] Default::default()
944 }
945 };
946 let m_relativePositionTolerance = match m_relativePositionTolerance {
947 _serde::__private::Some(__field) => __field,
948 _serde::__private::None => {
949 #[cfg(feature = "strict")]
950 return _serde::__private::Err(
951 <__A::Error as _serde::de::Error>::missing_field(
952 "relativePositionTolerance",
953 ),
954 );
955 #[cfg(not(feature = "strict"))] Default::default()
956 }
957 };
958 let m_rotationTolerance = match m_rotationTolerance {
959 _serde::__private::Some(__field) => __field,
960 _serde::__private::None => {
961 #[cfg(feature = "strict")]
962 return _serde::__private::Err(
963 <__A::Error as _serde::de::Error>::missing_field(
964 "rotationTolerance",
965 ),
966 );
967 #[cfg(not(feature = "strict"))] Default::default()
968 }
969 };
970 let m_scaleTolerance = match m_scaleTolerance {
971 _serde::__private::Some(__field) => __field,
972 _serde::__private::None => {
973 #[cfg(feature = "strict")]
974 return _serde::__private::Err(
975 <__A::Error as _serde::de::Error>::missing_field(
976 "scaleTolerance",
977 ),
978 );
979 #[cfg(not(feature = "strict"))] Default::default()
980 }
981 };
982 let m_absoluteFloatTolerance = match m_absoluteFloatTolerance {
983 _serde::__private::Some(__field) => __field,
984 _serde::__private::None => {
985 #[cfg(feature = "strict")]
986 return _serde::__private::Err(
987 <__A::Error as _serde::de::Error>::missing_field(
988 "absoluteFloatTolerance",
989 ),
990 );
991 #[cfg(not(feature = "strict"))] Default::default()
992 }
993 };
994 let __ptr = __A::class_ptr(&mut __map);
995 _serde::__private::Ok(hkaWaveletCompressedAnimationCompressionParams {
996 __ptr,
997 m_quantizationBits,
998 m_blockSize,
999 m_preserve,
1000 m_truncProp,
1001 m_useOldStyleTruncation,
1002 m_absolutePositionTolerance,
1003 m_relativePositionTolerance,
1004 m_rotationTolerance,
1005 m_scaleTolerance,
1006 m_absoluteFloatTolerance,
1007 })
1008 }
1009 }
1010 const FIELDS: &[&str] = &[
1011 "quantizationBits",
1012 "blockSize",
1013 "preserve",
1014 "truncProp",
1015 "useOldStyleTruncation",
1016 "absolutePositionTolerance",
1017 "relativePositionTolerance",
1018 "rotationTolerance",
1019 "scaleTolerance",
1020 "absoluteFloatTolerance",
1021 ];
1022 _serde::Deserializer::deserialize_struct(
1023 deserializer,
1024 "hkaWaveletCompressedAnimationCompressionParams",
1025 FIELDS,
1026 __hkaWaveletCompressedAnimationCompressionParamsVisitor {
1027 marker: _serde::__private::PhantomData::<
1028 hkaWaveletCompressedAnimationCompressionParams,
1029 >,
1030 lifetime: _serde::__private::PhantomData,
1031 },
1032 )
1033 }
1034 }
1035};