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 hkaSplineCompressedAnimationTrackCompressionParams {
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 = "rotationTolerance"))]
31 #[cfg_attr(feature = "serde", serde(rename = "rotationTolerance"))]
32 pub m_rotationTolerance: f32,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "translationTolerance"))]
38 #[cfg_attr(feature = "serde", serde(rename = "translationTolerance"))]
39 pub m_translationTolerance: f32,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "scaleTolerance"))]
45 #[cfg_attr(feature = "serde", serde(rename = "scaleTolerance"))]
46 pub m_scaleTolerance: f32,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "floatingTolerance"))]
52 #[cfg_attr(feature = "serde", serde(rename = "floatingTolerance"))]
53 pub m_floatingTolerance: f32,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "rotationDegree"))]
59 #[cfg_attr(feature = "serde", serde(rename = "rotationDegree"))]
60 pub m_rotationDegree: u16,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "translationDegree"))]
66 #[cfg_attr(feature = "serde", serde(rename = "translationDegree"))]
67 pub m_translationDegree: u16,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "scaleDegree"))]
73 #[cfg_attr(feature = "serde", serde(rename = "scaleDegree"))]
74 pub m_scaleDegree: u16,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "floatingDegree"))]
80 #[cfg_attr(feature = "serde", serde(rename = "floatingDegree"))]
81 pub m_floatingDegree: u16,
82 #[cfg_attr(feature = "json_schema", schemars(rename = "rotationQuantizationType"))]
87 #[cfg_attr(feature = "serde", serde(rename = "rotationQuantizationType"))]
88 pub m_rotationQuantizationType: RotationQuantization,
89 #[cfg_attr(
94 feature = "json_schema",
95 schemars(rename = "translationQuantizationType")
96 )]
97 #[cfg_attr(feature = "serde", serde(rename = "translationQuantizationType"))]
98 pub m_translationQuantizationType: ScalarQuantization,
99 #[cfg_attr(feature = "json_schema", schemars(rename = "scaleQuantizationType"))]
104 #[cfg_attr(feature = "serde", serde(rename = "scaleQuantizationType"))]
105 pub m_scaleQuantizationType: ScalarQuantization,
106 #[cfg_attr(feature = "json_schema", schemars(rename = "floatQuantizationType"))]
111 #[cfg_attr(feature = "serde", serde(rename = "floatQuantizationType"))]
112 pub m_floatQuantizationType: ScalarQuantization,
113}
114const _: () = {
115 use havok_serde as _serde;
116 impl _serde::HavokClass for hkaSplineCompressedAnimationTrackCompressionParams {
117 #[inline]
118 fn name(&self) -> &'static str {
119 "hkaSplineCompressedAnimationTrackCompressionParams"
120 }
121 #[inline]
122 fn signature(&self) -> _serde::__private::Signature {
123 _serde::__private::Signature::new(0x42e878d3)
124 }
125 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
126 fn deps_indexes(&self) -> Vec<usize> {
127 let mut v = Vec::new();
128 v
129 }
130 }
131 impl _serde::Serialize for hkaSplineCompressedAnimationTrackCompressionParams {
132 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
133 where
134 S: _serde::ser::Serializer,
135 {
136 let class_meta = self
137 .__ptr
138 .map(|name| (name, _serde::__private::Signature::new(0x42e878d3)));
139 let mut serializer = __serializer
140 .serialize_struct(
141 "hkaSplineCompressedAnimationTrackCompressionParams",
142 class_meta,
143 (28u64, 28u64),
144 )?;
145 serializer.serialize_field("rotationTolerance", &self.m_rotationTolerance)?;
146 serializer
147 .serialize_field("translationTolerance", &self.m_translationTolerance)?;
148 serializer.serialize_field("scaleTolerance", &self.m_scaleTolerance)?;
149 serializer.serialize_field("floatingTolerance", &self.m_floatingTolerance)?;
150 serializer.serialize_field("rotationDegree", &self.m_rotationDegree)?;
151 serializer.serialize_field("translationDegree", &self.m_translationDegree)?;
152 serializer.serialize_field("scaleDegree", &self.m_scaleDegree)?;
153 serializer.serialize_field("floatingDegree", &self.m_floatingDegree)?;
154 serializer
155 .serialize_field(
156 "rotationQuantizationType",
157 &self.m_rotationQuantizationType,
158 )?;
159 serializer
160 .serialize_field(
161 "translationQuantizationType",
162 &self.m_translationQuantizationType,
163 )?;
164 serializer
165 .serialize_field(
166 "scaleQuantizationType",
167 &self.m_scaleQuantizationType,
168 )?;
169 serializer
170 .serialize_field(
171 "floatQuantizationType",
172 &self.m_floatQuantizationType,
173 )?;
174 serializer.end()
175 }
176 }
177};
178#[doc(hidden)]
179#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
180const _: () = {
181 use havok_serde as _serde;
182 #[automatically_derived]
183 impl<'de> _serde::Deserialize<'de>
184 for hkaSplineCompressedAnimationTrackCompressionParams {
185 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
186 where
187 __D: _serde::Deserializer<'de>,
188 {
189 #[allow(non_camel_case_types)]
190 enum __Field {
191 m_rotationTolerance,
192 m_translationTolerance,
193 m_scaleTolerance,
194 m_floatingTolerance,
195 m_rotationDegree,
196 m_translationDegree,
197 m_scaleDegree,
198 m_floatingDegree,
199 m_rotationQuantizationType,
200 m_translationQuantizationType,
201 m_scaleQuantizationType,
202 m_floatQuantizationType,
203 __ignore,
204 }
205 struct __FieldVisitor;
206 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
207 type Value = __Field;
208 fn expecting(
209 &self,
210 __formatter: &mut core::fmt::Formatter,
211 ) -> core::fmt::Result {
212 core::fmt::Formatter::write_str(__formatter, "field identifier")
213 }
214 #[allow(clippy::match_single_binding)]
216 #[allow(clippy::reversed_empty_ranges)]
217 #[allow(clippy::single_match)]
218 fn visit_key<__E>(
219 self,
220 __value: &str,
221 ) -> core::result::Result<Self::Value, __E>
222 where
223 __E: _serde::de::Error,
224 {
225 match __value {
226 "rotationTolerance" => Ok(__Field::m_rotationTolerance),
227 "translationTolerance" => Ok(__Field::m_translationTolerance),
228 "scaleTolerance" => Ok(__Field::m_scaleTolerance),
229 "floatingTolerance" => Ok(__Field::m_floatingTolerance),
230 "rotationDegree" => Ok(__Field::m_rotationDegree),
231 "translationDegree" => Ok(__Field::m_translationDegree),
232 "scaleDegree" => Ok(__Field::m_scaleDegree),
233 "floatingDegree" => Ok(__Field::m_floatingDegree),
234 "rotationQuantizationType" => {
235 Ok(__Field::m_rotationQuantizationType)
236 }
237 "translationQuantizationType" => {
238 Ok(__Field::m_translationQuantizationType)
239 }
240 "scaleQuantizationType" => Ok(__Field::m_scaleQuantizationType),
241 "floatQuantizationType" => Ok(__Field::m_floatQuantizationType),
242 _ => Ok(__Field::__ignore),
243 }
244 }
245 }
246 impl<'de> _serde::Deserialize<'de> for __Field {
247 #[inline]
248 fn deserialize<__D>(
249 __deserializer: __D,
250 ) -> core::result::Result<Self, __D::Error>
251 where
252 __D: _serde::Deserializer<'de>,
253 {
254 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
255 }
256 }
257 struct __hkaSplineCompressedAnimationTrackCompressionParamsVisitor<'de> {
258 marker: _serde::__private::PhantomData<
259 hkaSplineCompressedAnimationTrackCompressionParams,
260 >,
261 lifetime: _serde::__private::PhantomData<&'de ()>,
262 }
263 #[allow(clippy::match_single_binding)]
264 #[allow(clippy::reversed_empty_ranges)]
265 #[allow(clippy::single_match)]
266 impl<'de> _serde::de::Visitor<'de>
267 for __hkaSplineCompressedAnimationTrackCompressionParamsVisitor<'de> {
268 type Value = hkaSplineCompressedAnimationTrackCompressionParams;
269 fn expecting(
270 &self,
271 __formatter: &mut core::fmt::Formatter,
272 ) -> core::fmt::Result {
273 core::fmt::Formatter::write_str(
274 __formatter,
275 "struct hkaSplineCompressedAnimationTrackCompressionParams",
276 )
277 }
278 fn visit_struct_for_bytes<__A>(
279 self,
280 mut __map: __A,
281 ) -> _serde::__private::Result<Self::Value, __A::Error>
282 where
283 __A: _serde::de::MapAccess<'de>,
284 {
285 let __ptr = __A::class_ptr(&mut __map);
286 let mut m_rotationTolerance: _serde::__private::Option<f32> = _serde::__private::None;
287 let mut m_translationTolerance: _serde::__private::Option<f32> = _serde::__private::None;
288 let mut m_scaleTolerance: _serde::__private::Option<f32> = _serde::__private::None;
289 let mut m_floatingTolerance: _serde::__private::Option<f32> = _serde::__private::None;
290 let mut m_rotationDegree: _serde::__private::Option<u16> = _serde::__private::None;
291 let mut m_translationDegree: _serde::__private::Option<u16> = _serde::__private::None;
292 let mut m_scaleDegree: _serde::__private::Option<u16> = _serde::__private::None;
293 let mut m_floatingDegree: _serde::__private::Option<u16> = _serde::__private::None;
294 let mut m_rotationQuantizationType: _serde::__private::Option<
295 RotationQuantization,
296 > = _serde::__private::None;
297 let mut m_translationQuantizationType: _serde::__private::Option<
298 ScalarQuantization,
299 > = _serde::__private::None;
300 let mut m_scaleQuantizationType: _serde::__private::Option<
301 ScalarQuantization,
302 > = _serde::__private::None;
303 let mut m_floatQuantizationType: _serde::__private::Option<
304 ScalarQuantization,
305 > = _serde::__private::None;
306 for i in 0..12usize {
307 match i {
308 0usize => {
309 if _serde::__private::Option::is_some(
310 &m_rotationTolerance,
311 ) {
312 return _serde::__private::Err(
313 <__A::Error as _serde::de::Error>::duplicate_field(
314 "rotationTolerance",
315 ),
316 );
317 }
318 m_rotationTolerance = _serde::__private::Some(
319 match __A::next_value::<f32>(&mut __map) {
320 _serde::__private::Ok(__val) => __val,
321 _serde::__private::Err(__err) => {
322 return _serde::__private::Err(__err);
323 }
324 },
325 );
326 }
327 1usize => {
328 if _serde::__private::Option::is_some(
329 &m_translationTolerance,
330 ) {
331 return _serde::__private::Err(
332 <__A::Error as _serde::de::Error>::duplicate_field(
333 "translationTolerance",
334 ),
335 );
336 }
337 m_translationTolerance = _serde::__private::Some(
338 match __A::next_value::<f32>(&mut __map) {
339 _serde::__private::Ok(__val) => __val,
340 _serde::__private::Err(__err) => {
341 return _serde::__private::Err(__err);
342 }
343 },
344 );
345 }
346 2usize => {
347 if _serde::__private::Option::is_some(&m_scaleTolerance) {
348 return _serde::__private::Err(
349 <__A::Error as _serde::de::Error>::duplicate_field(
350 "scaleTolerance",
351 ),
352 );
353 }
354 m_scaleTolerance = _serde::__private::Some(
355 match __A::next_value::<f32>(&mut __map) {
356 _serde::__private::Ok(__val) => __val,
357 _serde::__private::Err(__err) => {
358 return _serde::__private::Err(__err);
359 }
360 },
361 );
362 }
363 3usize => {
364 if _serde::__private::Option::is_some(
365 &m_floatingTolerance,
366 ) {
367 return _serde::__private::Err(
368 <__A::Error as _serde::de::Error>::duplicate_field(
369 "floatingTolerance",
370 ),
371 );
372 }
373 m_floatingTolerance = _serde::__private::Some(
374 match __A::next_value::<f32>(&mut __map) {
375 _serde::__private::Ok(__val) => __val,
376 _serde::__private::Err(__err) => {
377 return _serde::__private::Err(__err);
378 }
379 },
380 );
381 }
382 4usize => {
383 if _serde::__private::Option::is_some(&m_rotationDegree) {
384 return _serde::__private::Err(
385 <__A::Error as _serde::de::Error>::duplicate_field(
386 "rotationDegree",
387 ),
388 );
389 }
390 m_rotationDegree = _serde::__private::Some(
391 match __A::next_value::<u16>(&mut __map) {
392 _serde::__private::Ok(__val) => __val,
393 _serde::__private::Err(__err) => {
394 return _serde::__private::Err(__err);
395 }
396 },
397 );
398 }
399 5usize => {
400 if _serde::__private::Option::is_some(
401 &m_translationDegree,
402 ) {
403 return _serde::__private::Err(
404 <__A::Error as _serde::de::Error>::duplicate_field(
405 "translationDegree",
406 ),
407 );
408 }
409 m_translationDegree = _serde::__private::Some(
410 match __A::next_value::<u16>(&mut __map) {
411 _serde::__private::Ok(__val) => __val,
412 _serde::__private::Err(__err) => {
413 return _serde::__private::Err(__err);
414 }
415 },
416 );
417 }
418 6usize => {
419 if _serde::__private::Option::is_some(&m_scaleDegree) {
420 return _serde::__private::Err(
421 <__A::Error as _serde::de::Error>::duplicate_field(
422 "scaleDegree",
423 ),
424 );
425 }
426 m_scaleDegree = _serde::__private::Some(
427 match __A::next_value::<u16>(&mut __map) {
428 _serde::__private::Ok(__val) => __val,
429 _serde::__private::Err(__err) => {
430 return _serde::__private::Err(__err);
431 }
432 },
433 );
434 }
435 7usize => {
436 if _serde::__private::Option::is_some(&m_floatingDegree) {
437 return _serde::__private::Err(
438 <__A::Error as _serde::de::Error>::duplicate_field(
439 "floatingDegree",
440 ),
441 );
442 }
443 m_floatingDegree = _serde::__private::Some(
444 match __A::next_value::<u16>(&mut __map) {
445 _serde::__private::Ok(__val) => __val,
446 _serde::__private::Err(__err) => {
447 return _serde::__private::Err(__err);
448 }
449 },
450 );
451 }
452 8usize => {
453 if _serde::__private::Option::is_some(
454 &m_rotationQuantizationType,
455 ) {
456 return _serde::__private::Err(
457 <__A::Error as _serde::de::Error>::duplicate_field(
458 "rotationQuantizationType",
459 ),
460 );
461 }
462 m_rotationQuantizationType = _serde::__private::Some(
463 match __A::next_value::<RotationQuantization>(&mut __map) {
464 _serde::__private::Ok(__val) => __val,
465 _serde::__private::Err(__err) => {
466 return _serde::__private::Err(__err);
467 }
468 },
469 );
470 }
471 9usize => {
472 if _serde::__private::Option::is_some(
473 &m_translationQuantizationType,
474 ) {
475 return _serde::__private::Err(
476 <__A::Error as _serde::de::Error>::duplicate_field(
477 "translationQuantizationType",
478 ),
479 );
480 }
481 m_translationQuantizationType = _serde::__private::Some(
482 match __A::next_value::<ScalarQuantization>(&mut __map) {
483 _serde::__private::Ok(__val) => __val,
484 _serde::__private::Err(__err) => {
485 return _serde::__private::Err(__err);
486 }
487 },
488 );
489 }
490 10usize => {
491 if _serde::__private::Option::is_some(
492 &m_scaleQuantizationType,
493 ) {
494 return _serde::__private::Err(
495 <__A::Error as _serde::de::Error>::duplicate_field(
496 "scaleQuantizationType",
497 ),
498 );
499 }
500 m_scaleQuantizationType = _serde::__private::Some(
501 match __A::next_value::<ScalarQuantization>(&mut __map) {
502 _serde::__private::Ok(__val) => __val,
503 _serde::__private::Err(__err) => {
504 return _serde::__private::Err(__err);
505 }
506 },
507 );
508 }
509 11usize => {
510 if _serde::__private::Option::is_some(
511 &m_floatQuantizationType,
512 ) {
513 return _serde::__private::Err(
514 <__A::Error as _serde::de::Error>::duplicate_field(
515 "floatQuantizationType",
516 ),
517 );
518 }
519 m_floatQuantizationType = _serde::__private::Some(
520 match __A::next_value::<ScalarQuantization>(&mut __map) {
521 _serde::__private::Ok(__val) => __val,
522 _serde::__private::Err(__err) => {
523 return _serde::__private::Err(__err);
524 }
525 },
526 );
527 }
528 _ => {}
529 }
530 }
531 let m_rotationTolerance = match m_rotationTolerance {
532 _serde::__private::Some(__field) => __field,
533 _serde::__private::None => {
534 return _serde::__private::Err(
535 <__A::Error as _serde::de::Error>::missing_field(
536 "rotationTolerance",
537 ),
538 );
539 }
540 };
541 let m_translationTolerance = match m_translationTolerance {
542 _serde::__private::Some(__field) => __field,
543 _serde::__private::None => {
544 return _serde::__private::Err(
545 <__A::Error as _serde::de::Error>::missing_field(
546 "translationTolerance",
547 ),
548 );
549 }
550 };
551 let m_scaleTolerance = match m_scaleTolerance {
552 _serde::__private::Some(__field) => __field,
553 _serde::__private::None => {
554 return _serde::__private::Err(
555 <__A::Error as _serde::de::Error>::missing_field(
556 "scaleTolerance",
557 ),
558 );
559 }
560 };
561 let m_floatingTolerance = match m_floatingTolerance {
562 _serde::__private::Some(__field) => __field,
563 _serde::__private::None => {
564 return _serde::__private::Err(
565 <__A::Error as _serde::de::Error>::missing_field(
566 "floatingTolerance",
567 ),
568 );
569 }
570 };
571 let m_rotationDegree = match m_rotationDegree {
572 _serde::__private::Some(__field) => __field,
573 _serde::__private::None => {
574 return _serde::__private::Err(
575 <__A::Error as _serde::de::Error>::missing_field(
576 "rotationDegree",
577 ),
578 );
579 }
580 };
581 let m_translationDegree = match m_translationDegree {
582 _serde::__private::Some(__field) => __field,
583 _serde::__private::None => {
584 return _serde::__private::Err(
585 <__A::Error as _serde::de::Error>::missing_field(
586 "translationDegree",
587 ),
588 );
589 }
590 };
591 let m_scaleDegree = match m_scaleDegree {
592 _serde::__private::Some(__field) => __field,
593 _serde::__private::None => {
594 return _serde::__private::Err(
595 <__A::Error as _serde::de::Error>::missing_field(
596 "scaleDegree",
597 ),
598 );
599 }
600 };
601 let m_floatingDegree = match m_floatingDegree {
602 _serde::__private::Some(__field) => __field,
603 _serde::__private::None => {
604 return _serde::__private::Err(
605 <__A::Error as _serde::de::Error>::missing_field(
606 "floatingDegree",
607 ),
608 );
609 }
610 };
611 let m_rotationQuantizationType = match m_rotationQuantizationType {
612 _serde::__private::Some(__field) => __field,
613 _serde::__private::None => {
614 return _serde::__private::Err(
615 <__A::Error as _serde::de::Error>::missing_field(
616 "rotationQuantizationType",
617 ),
618 );
619 }
620 };
621 let m_translationQuantizationType = match m_translationQuantizationType {
622 _serde::__private::Some(__field) => __field,
623 _serde::__private::None => {
624 return _serde::__private::Err(
625 <__A::Error as _serde::de::Error>::missing_field(
626 "translationQuantizationType",
627 ),
628 );
629 }
630 };
631 let m_scaleQuantizationType = match m_scaleQuantizationType {
632 _serde::__private::Some(__field) => __field,
633 _serde::__private::None => {
634 return _serde::__private::Err(
635 <__A::Error as _serde::de::Error>::missing_field(
636 "scaleQuantizationType",
637 ),
638 );
639 }
640 };
641 let m_floatQuantizationType = match m_floatQuantizationType {
642 _serde::__private::Some(__field) => __field,
643 _serde::__private::None => {
644 return _serde::__private::Err(
645 <__A::Error as _serde::de::Error>::missing_field(
646 "floatQuantizationType",
647 ),
648 );
649 }
650 };
651 _serde::__private::Ok(hkaSplineCompressedAnimationTrackCompressionParams {
652 __ptr,
653 m_rotationTolerance,
654 m_translationTolerance,
655 m_scaleTolerance,
656 m_floatingTolerance,
657 m_rotationDegree,
658 m_translationDegree,
659 m_scaleDegree,
660 m_floatingDegree,
661 m_rotationQuantizationType,
662 m_translationQuantizationType,
663 m_scaleQuantizationType,
664 m_floatQuantizationType,
665 })
666 }
667 #[allow(clippy::manual_unwrap_or_default)]
668 fn visit_struct<__A>(
669 self,
670 mut __map: __A,
671 ) -> _serde::__private::Result<Self::Value, __A::Error>
672 where
673 __A: _serde::de::MapAccess<'de>,
674 {
675 let mut m_rotationTolerance: _serde::__private::Option<f32> = _serde::__private::None;
676 let mut m_translationTolerance: _serde::__private::Option<f32> = _serde::__private::None;
677 let mut m_scaleTolerance: _serde::__private::Option<f32> = _serde::__private::None;
678 let mut m_floatingTolerance: _serde::__private::Option<f32> = _serde::__private::None;
679 let mut m_rotationDegree: _serde::__private::Option<u16> = _serde::__private::None;
680 let mut m_translationDegree: _serde::__private::Option<u16> = _serde::__private::None;
681 let mut m_scaleDegree: _serde::__private::Option<u16> = _serde::__private::None;
682 let mut m_floatingDegree: _serde::__private::Option<u16> = _serde::__private::None;
683 let mut m_rotationQuantizationType: _serde::__private::Option<
684 RotationQuantization,
685 > = _serde::__private::None;
686 let mut m_translationQuantizationType: _serde::__private::Option<
687 ScalarQuantization,
688 > = _serde::__private::None;
689 let mut m_scaleQuantizationType: _serde::__private::Option<
690 ScalarQuantization,
691 > = _serde::__private::None;
692 let mut m_floatQuantizationType: _serde::__private::Option<
693 ScalarQuantization,
694 > = _serde::__private::None;
695 while let _serde::__private::Some(__key) = {
696 __A::next_key::<__Field>(&mut __map)?
697 } {
698 match __key {
699 __Field::m_rotationTolerance => {
700 #[cfg(
701 any(feature = "strict", feature = "ignore_duplicates")
702 )]
703 if _serde::__private::Option::is_some(
704 &m_rotationTolerance,
705 ) {
706 #[cfg(feature = "ignore_duplicates")]
707 {
708 __A::skip_value(&mut __map)?;
709 continue;
710 }
711 #[cfg(feature = "strict")]
712 return _serde::__private::Err(
713 <__A::Error as _serde::de::Error>::duplicate_field(
714 "rotationTolerance",
715 ),
716 );
717 }
718 m_rotationTolerance = _serde::__private::Some(
719 match __A::next_value::<f32>(&mut __map) {
720 _serde::__private::Ok(__val) => __val,
721 _serde::__private::Err(__err) => {
722 return _serde::__private::Err(__err);
723 }
724 },
725 );
726 }
727 __Field::m_translationTolerance => {
728 #[cfg(
729 any(feature = "strict", feature = "ignore_duplicates")
730 )]
731 if _serde::__private::Option::is_some(
732 &m_translationTolerance,
733 ) {
734 #[cfg(feature = "ignore_duplicates")]
735 {
736 __A::skip_value(&mut __map)?;
737 continue;
738 }
739 #[cfg(feature = "strict")]
740 return _serde::__private::Err(
741 <__A::Error as _serde::de::Error>::duplicate_field(
742 "translationTolerance",
743 ),
744 );
745 }
746 m_translationTolerance = _serde::__private::Some(
747 match __A::next_value::<f32>(&mut __map) {
748 _serde::__private::Ok(__val) => __val,
749 _serde::__private::Err(__err) => {
750 return _serde::__private::Err(__err);
751 }
752 },
753 );
754 }
755 __Field::m_scaleTolerance => {
756 #[cfg(
757 any(feature = "strict", feature = "ignore_duplicates")
758 )]
759 if _serde::__private::Option::is_some(&m_scaleTolerance) {
760 #[cfg(feature = "ignore_duplicates")]
761 {
762 __A::skip_value(&mut __map)?;
763 continue;
764 }
765 #[cfg(feature = "strict")]
766 return _serde::__private::Err(
767 <__A::Error as _serde::de::Error>::duplicate_field(
768 "scaleTolerance",
769 ),
770 );
771 }
772 m_scaleTolerance = _serde::__private::Some(
773 match __A::next_value::<f32>(&mut __map) {
774 _serde::__private::Ok(__val) => __val,
775 _serde::__private::Err(__err) => {
776 return _serde::__private::Err(__err);
777 }
778 },
779 );
780 }
781 __Field::m_floatingTolerance => {
782 #[cfg(
783 any(feature = "strict", feature = "ignore_duplicates")
784 )]
785 if _serde::__private::Option::is_some(
786 &m_floatingTolerance,
787 ) {
788 #[cfg(feature = "ignore_duplicates")]
789 {
790 __A::skip_value(&mut __map)?;
791 continue;
792 }
793 #[cfg(feature = "strict")]
794 return _serde::__private::Err(
795 <__A::Error as _serde::de::Error>::duplicate_field(
796 "floatingTolerance",
797 ),
798 );
799 }
800 m_floatingTolerance = _serde::__private::Some(
801 match __A::next_value::<f32>(&mut __map) {
802 _serde::__private::Ok(__val) => __val,
803 _serde::__private::Err(__err) => {
804 return _serde::__private::Err(__err);
805 }
806 },
807 );
808 }
809 __Field::m_rotationDegree => {
810 #[cfg(
811 any(feature = "strict", feature = "ignore_duplicates")
812 )]
813 if _serde::__private::Option::is_some(&m_rotationDegree) {
814 #[cfg(feature = "ignore_duplicates")]
815 {
816 __A::skip_value(&mut __map)?;
817 continue;
818 }
819 #[cfg(feature = "strict")]
820 return _serde::__private::Err(
821 <__A::Error as _serde::de::Error>::duplicate_field(
822 "rotationDegree",
823 ),
824 );
825 }
826 m_rotationDegree = _serde::__private::Some(
827 match __A::next_value::<u16>(&mut __map) {
828 _serde::__private::Ok(__val) => __val,
829 _serde::__private::Err(__err) => {
830 return _serde::__private::Err(__err);
831 }
832 },
833 );
834 }
835 __Field::m_translationDegree => {
836 #[cfg(
837 any(feature = "strict", feature = "ignore_duplicates")
838 )]
839 if _serde::__private::Option::is_some(
840 &m_translationDegree,
841 ) {
842 #[cfg(feature = "ignore_duplicates")]
843 {
844 __A::skip_value(&mut __map)?;
845 continue;
846 }
847 #[cfg(feature = "strict")]
848 return _serde::__private::Err(
849 <__A::Error as _serde::de::Error>::duplicate_field(
850 "translationDegree",
851 ),
852 );
853 }
854 m_translationDegree = _serde::__private::Some(
855 match __A::next_value::<u16>(&mut __map) {
856 _serde::__private::Ok(__val) => __val,
857 _serde::__private::Err(__err) => {
858 return _serde::__private::Err(__err);
859 }
860 },
861 );
862 }
863 __Field::m_scaleDegree => {
864 #[cfg(
865 any(feature = "strict", feature = "ignore_duplicates")
866 )]
867 if _serde::__private::Option::is_some(&m_scaleDegree) {
868 #[cfg(feature = "ignore_duplicates")]
869 {
870 __A::skip_value(&mut __map)?;
871 continue;
872 }
873 #[cfg(feature = "strict")]
874 return _serde::__private::Err(
875 <__A::Error as _serde::de::Error>::duplicate_field(
876 "scaleDegree",
877 ),
878 );
879 }
880 m_scaleDegree = _serde::__private::Some(
881 match __A::next_value::<u16>(&mut __map) {
882 _serde::__private::Ok(__val) => __val,
883 _serde::__private::Err(__err) => {
884 return _serde::__private::Err(__err);
885 }
886 },
887 );
888 }
889 __Field::m_floatingDegree => {
890 #[cfg(
891 any(feature = "strict", feature = "ignore_duplicates")
892 )]
893 if _serde::__private::Option::is_some(&m_floatingDegree) {
894 #[cfg(feature = "ignore_duplicates")]
895 {
896 __A::skip_value(&mut __map)?;
897 continue;
898 }
899 #[cfg(feature = "strict")]
900 return _serde::__private::Err(
901 <__A::Error as _serde::de::Error>::duplicate_field(
902 "floatingDegree",
903 ),
904 );
905 }
906 m_floatingDegree = _serde::__private::Some(
907 match __A::next_value::<u16>(&mut __map) {
908 _serde::__private::Ok(__val) => __val,
909 _serde::__private::Err(__err) => {
910 return _serde::__private::Err(__err);
911 }
912 },
913 );
914 }
915 __Field::m_rotationQuantizationType => {
916 #[cfg(
917 any(feature = "strict", feature = "ignore_duplicates")
918 )]
919 if _serde::__private::Option::is_some(
920 &m_rotationQuantizationType,
921 ) {
922 #[cfg(feature = "ignore_duplicates")]
923 {
924 __A::skip_value(&mut __map)?;
925 continue;
926 }
927 #[cfg(feature = "strict")]
928 return _serde::__private::Err(
929 <__A::Error as _serde::de::Error>::duplicate_field(
930 "rotationQuantizationType",
931 ),
932 );
933 }
934 m_rotationQuantizationType = _serde::__private::Some(
935 match __A::next_value::<RotationQuantization>(&mut __map) {
936 _serde::__private::Ok(__val) => __val,
937 _serde::__private::Err(__err) => {
938 return _serde::__private::Err(__err);
939 }
940 },
941 );
942 }
943 __Field::m_translationQuantizationType => {
944 #[cfg(
945 any(feature = "strict", feature = "ignore_duplicates")
946 )]
947 if _serde::__private::Option::is_some(
948 &m_translationQuantizationType,
949 ) {
950 #[cfg(feature = "ignore_duplicates")]
951 {
952 __A::skip_value(&mut __map)?;
953 continue;
954 }
955 #[cfg(feature = "strict")]
956 return _serde::__private::Err(
957 <__A::Error as _serde::de::Error>::duplicate_field(
958 "translationQuantizationType",
959 ),
960 );
961 }
962 m_translationQuantizationType = _serde::__private::Some(
963 match __A::next_value::<ScalarQuantization>(&mut __map) {
964 _serde::__private::Ok(__val) => __val,
965 _serde::__private::Err(__err) => {
966 return _serde::__private::Err(__err);
967 }
968 },
969 );
970 }
971 __Field::m_scaleQuantizationType => {
972 #[cfg(
973 any(feature = "strict", feature = "ignore_duplicates")
974 )]
975 if _serde::__private::Option::is_some(
976 &m_scaleQuantizationType,
977 ) {
978 #[cfg(feature = "ignore_duplicates")]
979 {
980 __A::skip_value(&mut __map)?;
981 continue;
982 }
983 #[cfg(feature = "strict")]
984 return _serde::__private::Err(
985 <__A::Error as _serde::de::Error>::duplicate_field(
986 "scaleQuantizationType",
987 ),
988 );
989 }
990 m_scaleQuantizationType = _serde::__private::Some(
991 match __A::next_value::<ScalarQuantization>(&mut __map) {
992 _serde::__private::Ok(__val) => __val,
993 _serde::__private::Err(__err) => {
994 return _serde::__private::Err(__err);
995 }
996 },
997 );
998 }
999 __Field::m_floatQuantizationType => {
1000 #[cfg(
1001 any(feature = "strict", feature = "ignore_duplicates")
1002 )]
1003 if _serde::__private::Option::is_some(
1004 &m_floatQuantizationType,
1005 ) {
1006 #[cfg(feature = "ignore_duplicates")]
1007 {
1008 __A::skip_value(&mut __map)?;
1009 continue;
1010 }
1011 #[cfg(feature = "strict")]
1012 return _serde::__private::Err(
1013 <__A::Error as _serde::de::Error>::duplicate_field(
1014 "floatQuantizationType",
1015 ),
1016 );
1017 }
1018 m_floatQuantizationType = _serde::__private::Some(
1019 match __A::next_value::<ScalarQuantization>(&mut __map) {
1020 _serde::__private::Ok(__val) => __val,
1021 _serde::__private::Err(__err) => {
1022 return _serde::__private::Err(__err);
1023 }
1024 },
1025 );
1026 }
1027 _ => __A::skip_value(&mut __map)?,
1028 }
1029 }
1030 let m_rotationTolerance = match m_rotationTolerance {
1031 _serde::__private::Some(__field) => __field,
1032 _serde::__private::None => {
1033 #[cfg(feature = "strict")]
1034 return _serde::__private::Err(
1035 <__A::Error as _serde::de::Error>::missing_field(
1036 "rotationTolerance",
1037 ),
1038 );
1039 #[cfg(not(feature = "strict"))] Default::default()
1040 }
1041 };
1042 let m_translationTolerance = match m_translationTolerance {
1043 _serde::__private::Some(__field) => __field,
1044 _serde::__private::None => {
1045 #[cfg(feature = "strict")]
1046 return _serde::__private::Err(
1047 <__A::Error as _serde::de::Error>::missing_field(
1048 "translationTolerance",
1049 ),
1050 );
1051 #[cfg(not(feature = "strict"))] Default::default()
1052 }
1053 };
1054 let m_scaleTolerance = match m_scaleTolerance {
1055 _serde::__private::Some(__field) => __field,
1056 _serde::__private::None => {
1057 #[cfg(feature = "strict")]
1058 return _serde::__private::Err(
1059 <__A::Error as _serde::de::Error>::missing_field(
1060 "scaleTolerance",
1061 ),
1062 );
1063 #[cfg(not(feature = "strict"))] Default::default()
1064 }
1065 };
1066 let m_floatingTolerance = match m_floatingTolerance {
1067 _serde::__private::Some(__field) => __field,
1068 _serde::__private::None => {
1069 #[cfg(feature = "strict")]
1070 return _serde::__private::Err(
1071 <__A::Error as _serde::de::Error>::missing_field(
1072 "floatingTolerance",
1073 ),
1074 );
1075 #[cfg(not(feature = "strict"))] Default::default()
1076 }
1077 };
1078 let m_rotationDegree = match m_rotationDegree {
1079 _serde::__private::Some(__field) => __field,
1080 _serde::__private::None => {
1081 #[cfg(feature = "strict")]
1082 return _serde::__private::Err(
1083 <__A::Error as _serde::de::Error>::missing_field(
1084 "rotationDegree",
1085 ),
1086 );
1087 #[cfg(not(feature = "strict"))] Default::default()
1088 }
1089 };
1090 let m_translationDegree = match m_translationDegree {
1091 _serde::__private::Some(__field) => __field,
1092 _serde::__private::None => {
1093 #[cfg(feature = "strict")]
1094 return _serde::__private::Err(
1095 <__A::Error as _serde::de::Error>::missing_field(
1096 "translationDegree",
1097 ),
1098 );
1099 #[cfg(not(feature = "strict"))] Default::default()
1100 }
1101 };
1102 let m_scaleDegree = match m_scaleDegree {
1103 _serde::__private::Some(__field) => __field,
1104 _serde::__private::None => {
1105 #[cfg(feature = "strict")]
1106 return _serde::__private::Err(
1107 <__A::Error as _serde::de::Error>::missing_field(
1108 "scaleDegree",
1109 ),
1110 );
1111 #[cfg(not(feature = "strict"))] Default::default()
1112 }
1113 };
1114 let m_floatingDegree = match m_floatingDegree {
1115 _serde::__private::Some(__field) => __field,
1116 _serde::__private::None => {
1117 #[cfg(feature = "strict")]
1118 return _serde::__private::Err(
1119 <__A::Error as _serde::de::Error>::missing_field(
1120 "floatingDegree",
1121 ),
1122 );
1123 #[cfg(not(feature = "strict"))] Default::default()
1124 }
1125 };
1126 let m_rotationQuantizationType = match m_rotationQuantizationType {
1127 _serde::__private::Some(__field) => __field,
1128 _serde::__private::None => {
1129 #[cfg(feature = "strict")]
1130 return _serde::__private::Err(
1131 <__A::Error as _serde::de::Error>::missing_field(
1132 "rotationQuantizationType",
1133 ),
1134 );
1135 #[cfg(not(feature = "strict"))] Default::default()
1136 }
1137 };
1138 let m_translationQuantizationType = match m_translationQuantizationType {
1139 _serde::__private::Some(__field) => __field,
1140 _serde::__private::None => {
1141 #[cfg(feature = "strict")]
1142 return _serde::__private::Err(
1143 <__A::Error as _serde::de::Error>::missing_field(
1144 "translationQuantizationType",
1145 ),
1146 );
1147 #[cfg(not(feature = "strict"))] Default::default()
1148 }
1149 };
1150 let m_scaleQuantizationType = match m_scaleQuantizationType {
1151 _serde::__private::Some(__field) => __field,
1152 _serde::__private::None => {
1153 #[cfg(feature = "strict")]
1154 return _serde::__private::Err(
1155 <__A::Error as _serde::de::Error>::missing_field(
1156 "scaleQuantizationType",
1157 ),
1158 );
1159 #[cfg(not(feature = "strict"))] Default::default()
1160 }
1161 };
1162 let m_floatQuantizationType = match m_floatQuantizationType {
1163 _serde::__private::Some(__field) => __field,
1164 _serde::__private::None => {
1165 #[cfg(feature = "strict")]
1166 return _serde::__private::Err(
1167 <__A::Error as _serde::de::Error>::missing_field(
1168 "floatQuantizationType",
1169 ),
1170 );
1171 #[cfg(not(feature = "strict"))] Default::default()
1172 }
1173 };
1174 let __ptr = __A::class_ptr(&mut __map);
1175 _serde::__private::Ok(hkaSplineCompressedAnimationTrackCompressionParams {
1176 __ptr,
1177 m_rotationTolerance,
1178 m_translationTolerance,
1179 m_scaleTolerance,
1180 m_floatingTolerance,
1181 m_rotationDegree,
1182 m_translationDegree,
1183 m_scaleDegree,
1184 m_floatingDegree,
1185 m_rotationQuantizationType,
1186 m_translationQuantizationType,
1187 m_scaleQuantizationType,
1188 m_floatQuantizationType,
1189 })
1190 }
1191 }
1192 const FIELDS: &[&str] = &[
1193 "rotationTolerance",
1194 "translationTolerance",
1195 "scaleTolerance",
1196 "floatingTolerance",
1197 "rotationDegree",
1198 "translationDegree",
1199 "scaleDegree",
1200 "floatingDegree",
1201 "rotationQuantizationType",
1202 "translationQuantizationType",
1203 "scaleQuantizationType",
1204 "floatQuantizationType",
1205 ];
1206 _serde::Deserializer::deserialize_struct(
1207 deserializer,
1208 "hkaSplineCompressedAnimationTrackCompressionParams",
1209 FIELDS,
1210 __hkaSplineCompressedAnimationTrackCompressionParamsVisitor {
1211 marker: _serde::__private::PhantomData::<
1212 hkaSplineCompressedAnimationTrackCompressionParams,
1213 >,
1214 lifetime: _serde::__private::PhantomData,
1215 },
1216 )
1217 }
1218 }
1219};
1220#[allow(non_upper_case_globals, non_snake_case)]
1223#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1224#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1225#[derive(
1226 Debug,
1227 Clone,
1228 Default,
1229 PartialEq,
1230 Eq,
1231 PartialOrd,
1232 Ord,
1233 num_derive::ToPrimitive,
1234 num_derive::FromPrimitive,
1235)]
1236pub enum RotationQuantization {
1237 #[default]
1238 POLAR32 = 0isize,
1239 THREECOMP40 = 1isize,
1240 THREECOMP48 = 2isize,
1241 THREECOMP24 = 3isize,
1242 STRAIGHT16 = 4isize,
1243 UNCOMPRESSED = 5isize,
1244}
1245#[allow(non_upper_case_globals, non_snake_case)]
1248#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1249#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1250#[derive(
1251 Debug,
1252 Clone,
1253 Default,
1254 PartialEq,
1255 Eq,
1256 PartialOrd,
1257 Ord,
1258 num_derive::ToPrimitive,
1259 num_derive::FromPrimitive,
1260)]
1261pub enum ScalarQuantization {
1262 #[default]
1263 BITS8 = 0isize,
1264 BITS16 = 1isize,
1265}
1266const _: () = {
1267 use havok_serde as __serde;
1268 impl __serde::Serialize for RotationQuantization {
1269 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1270 where
1271 S: __serde::ser::Serializer,
1272 {
1273 let mut __serializer = __serializer.serialize_enum_flags()?;
1274 match self {
1275 Self::POLAR32 => __serializer.serialize_field("POLAR32", &0u64),
1276 Self::THREECOMP40 => __serializer.serialize_field("THREECOMP40", &1u64),
1277 Self::THREECOMP48 => __serializer.serialize_field("THREECOMP48", &2u64),
1278 Self::THREECOMP24 => __serializer.serialize_field("THREECOMP24", &3u64),
1279 Self::STRAIGHT16 => __serializer.serialize_field("STRAIGHT16", &4u64),
1280 Self::UNCOMPRESSED => __serializer.serialize_field("UNCOMPRESSED", &5u64),
1281 }?;
1282 use num_traits::ToPrimitive as _;
1283 let num = self
1284 .to_u8()
1285 .ok_or(S::Error::custom("Failed enum RotationQuantization to_u8"))?;
1286 __serializer.serialize_bits(&num)?;
1287 __serializer.end()
1288 }
1289 }
1290};
1291const _: () = {
1292 use havok_serde as __serde;
1293 impl __serde::Serialize for ScalarQuantization {
1294 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1295 where
1296 S: __serde::ser::Serializer,
1297 {
1298 let mut __serializer = __serializer.serialize_enum_flags()?;
1299 match self {
1300 Self::BITS8 => __serializer.serialize_field("BITS8", &0u64),
1301 Self::BITS16 => __serializer.serialize_field("BITS16", &1u64),
1302 }?;
1303 use num_traits::ToPrimitive as _;
1304 let num = self
1305 .to_u8()
1306 .ok_or(S::Error::custom("Failed enum ScalarQuantization to_u8"))?;
1307 __serializer.serialize_bits(&num)?;
1308 __serializer.end()
1309 }
1310 }
1311};
1312#[doc(hidden)]
1313#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1314const _: () = {
1315 #[allow(unused_extern_crates, clippy::useless_attribute)]
1316 extern crate havok_serde as _serde;
1317 #[automatically_derived]
1318 impl<'de> _serde::Deserialize<'de> for RotationQuantization {
1319 fn deserialize<__D>(
1320 __deserializer: __D,
1321 ) -> _serde::__private::Result<Self, __D::Error>
1322 where
1323 __D: _serde::Deserializer<'de>,
1324 {
1325 #[allow(non_camel_case_types)]
1326 #[doc(hidden)]
1327 enum __Field {
1328 __field0,
1329 __field1,
1330 __field2,
1331 __field3,
1332 __field4,
1333 __field5,
1334 }
1335 #[doc(hidden)]
1336 struct __FieldVisitor;
1337 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1338 type Value = __Field;
1339 fn expecting(
1340 &self,
1341 __formatter: &mut _serde::__private::Formatter,
1342 ) -> _serde::__private::fmt::Result {
1343 _serde::__private::Formatter::write_str(
1344 __formatter,
1345 "variant identifier",
1346 )
1347 }
1348 fn visit_uint8<__E>(
1349 self,
1350 __value: u8,
1351 ) -> _serde::__private::Result<Self::Value, __E>
1352 where
1353 __E: _serde::de::Error,
1354 {
1355 match __value {
1356 0u8 => _serde::__private::Ok(__Field::__field0),
1357 1u8 => _serde::__private::Ok(__Field::__field1),
1358 2u8 => _serde::__private::Ok(__Field::__field2),
1359 3u8 => _serde::__private::Ok(__Field::__field3),
1360 4u8 => _serde::__private::Ok(__Field::__field4),
1361 5u8 => _serde::__private::Ok(__Field::__field5),
1362 _ => {
1363 _serde::__private::Err(
1364 _serde::de::Error::invalid_value(
1365 _serde::de::Unexpected::Uint8(__value),
1366 &"value(u8) of variant is one of 0, 1, 2, 3, 4, 5",
1367 ),
1368 )
1369 }
1370 }
1371 }
1372 fn visit_stringptr<__E>(
1373 self,
1374 __value: StringPtr<'de>,
1375 ) -> _serde::__private::Result<Self::Value, __E>
1376 where
1377 __E: _serde::de::Error,
1378 {
1379 if let Some(__value) = __value.into_inner() {
1380 match __value.as_ref() {
1381 v if v == "0" || v.eq_ignore_ascii_case("POLAR32") => {
1382 _serde::__private::Ok(__Field::__field0)
1383 }
1384 v if v == "1" || v.eq_ignore_ascii_case("THREECOMP40") => {
1385 _serde::__private::Ok(__Field::__field1)
1386 }
1387 v if v == "2" || v.eq_ignore_ascii_case("THREECOMP48") => {
1388 _serde::__private::Ok(__Field::__field2)
1389 }
1390 v if v == "3" || v.eq_ignore_ascii_case("THREECOMP24") => {
1391 _serde::__private::Ok(__Field::__field3)
1392 }
1393 v if v == "4" || v.eq_ignore_ascii_case("STRAIGHT16") => {
1394 _serde::__private::Ok(__Field::__field4)
1395 }
1396 v if v == "5" || v.eq_ignore_ascii_case("UNCOMPRESSED") => {
1397 _serde::__private::Ok(__Field::__field5)
1398 }
1399 _ => {
1400 _serde::__private::Err(
1401 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1402 )
1403 }
1404 }
1405 } else {
1406 _serde::__private::Err(
1407 _serde::de::Error::unknown_variant("None", VARIANTS),
1408 )
1409 }
1410 }
1411 }
1412 impl<'de> _serde::Deserialize<'de> for __Field {
1413 #[inline]
1414 fn deserialize<__D>(
1415 __deserializer: __D,
1416 ) -> _serde::__private::Result<Self, __D::Error>
1417 where
1418 __D: _serde::Deserializer<'de>,
1419 {
1420 _serde::Deserializer::deserialize_identifier(
1421 __deserializer,
1422 _serde::de::ReadEnumSize::Uint8,
1423 __FieldVisitor,
1424 )
1425 }
1426 }
1427 #[doc(hidden)]
1428 struct __Visitor<'de> {
1429 marker: _serde::__private::PhantomData<RotationQuantization>,
1430 lifetime: _serde::__private::PhantomData<&'de ()>,
1431 }
1432 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1433 type Value = RotationQuantization;
1434 fn expecting(
1435 &self,
1436 __formatter: &mut _serde::__private::Formatter,
1437 ) -> _serde::__private::fmt::Result {
1438 _serde::__private::Formatter::write_str(
1439 __formatter,
1440 "enum RotationQuantization",
1441 )
1442 }
1443 fn visit_enum<__A>(
1444 self,
1445 __data: __A,
1446 ) -> _serde::__private::Result<Self::Value, __A::Error>
1447 where
1448 __A: _serde::de::EnumAccess<'de>,
1449 {
1450 match _serde::de::EnumAccess::variant(__data)? {
1451 (__Field::__field0, __variant) => {
1452 _serde::de::VariantAccess::unit_variant(__variant)?;
1453 _serde::__private::Ok(RotationQuantization::POLAR32)
1454 }
1455 (__Field::__field1, __variant) => {
1456 _serde::de::VariantAccess::unit_variant(__variant)?;
1457 _serde::__private::Ok(RotationQuantization::THREECOMP40)
1458 }
1459 (__Field::__field2, __variant) => {
1460 _serde::de::VariantAccess::unit_variant(__variant)?;
1461 _serde::__private::Ok(RotationQuantization::THREECOMP48)
1462 }
1463 (__Field::__field3, __variant) => {
1464 _serde::de::VariantAccess::unit_variant(__variant)?;
1465 _serde::__private::Ok(RotationQuantization::THREECOMP24)
1466 }
1467 (__Field::__field4, __variant) => {
1468 _serde::de::VariantAccess::unit_variant(__variant)?;
1469 _serde::__private::Ok(RotationQuantization::STRAIGHT16)
1470 }
1471 (__Field::__field5, __variant) => {
1472 _serde::de::VariantAccess::unit_variant(__variant)?;
1473 _serde::__private::Ok(RotationQuantization::UNCOMPRESSED)
1474 }
1475 }
1476 }
1477 }
1478 #[doc(hidden)]
1479 const VARIANTS: &'static [&'static str] = &[
1480 "POLAR32",
1481 "THREECOMP40",
1482 "THREECOMP48",
1483 "THREECOMP24",
1484 "STRAIGHT16",
1485 "UNCOMPRESSED",
1486 ];
1487 _serde::Deserializer::deserialize_enum(
1488 __deserializer,
1489 "RotationQuantization",
1490 VARIANTS,
1491 __Visitor {
1492 marker: _serde::__private::PhantomData::<RotationQuantization>,
1493 lifetime: _serde::__private::PhantomData,
1494 },
1495 )
1496 }
1497 }
1498};
1499#[doc(hidden)]
1500#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1501const _: () = {
1502 #[allow(unused_extern_crates, clippy::useless_attribute)]
1503 extern crate havok_serde as _serde;
1504 #[automatically_derived]
1505 impl<'de> _serde::Deserialize<'de> for ScalarQuantization {
1506 fn deserialize<__D>(
1507 __deserializer: __D,
1508 ) -> _serde::__private::Result<Self, __D::Error>
1509 where
1510 __D: _serde::Deserializer<'de>,
1511 {
1512 #[allow(non_camel_case_types)]
1513 #[doc(hidden)]
1514 enum __Field {
1515 __field0,
1516 __field1,
1517 }
1518 #[doc(hidden)]
1519 struct __FieldVisitor;
1520 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1521 type Value = __Field;
1522 fn expecting(
1523 &self,
1524 __formatter: &mut _serde::__private::Formatter,
1525 ) -> _serde::__private::fmt::Result {
1526 _serde::__private::Formatter::write_str(
1527 __formatter,
1528 "variant identifier",
1529 )
1530 }
1531 fn visit_uint8<__E>(
1532 self,
1533 __value: u8,
1534 ) -> _serde::__private::Result<Self::Value, __E>
1535 where
1536 __E: _serde::de::Error,
1537 {
1538 match __value {
1539 0u8 => _serde::__private::Ok(__Field::__field0),
1540 1u8 => _serde::__private::Ok(__Field::__field1),
1541 _ => {
1542 _serde::__private::Err(
1543 _serde::de::Error::invalid_value(
1544 _serde::de::Unexpected::Uint8(__value),
1545 &"value(u8) of variant is one of 0, 1",
1546 ),
1547 )
1548 }
1549 }
1550 }
1551 fn visit_stringptr<__E>(
1552 self,
1553 __value: StringPtr<'de>,
1554 ) -> _serde::__private::Result<Self::Value, __E>
1555 where
1556 __E: _serde::de::Error,
1557 {
1558 if let Some(__value) = __value.into_inner() {
1559 match __value.as_ref() {
1560 v if v == "0" || v.eq_ignore_ascii_case("BITS8") => {
1561 _serde::__private::Ok(__Field::__field0)
1562 }
1563 v if v == "1" || v.eq_ignore_ascii_case("BITS16") => {
1564 _serde::__private::Ok(__Field::__field1)
1565 }
1566 _ => {
1567 _serde::__private::Err(
1568 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1569 )
1570 }
1571 }
1572 } else {
1573 _serde::__private::Err(
1574 _serde::de::Error::unknown_variant("None", VARIANTS),
1575 )
1576 }
1577 }
1578 }
1579 impl<'de> _serde::Deserialize<'de> for __Field {
1580 #[inline]
1581 fn deserialize<__D>(
1582 __deserializer: __D,
1583 ) -> _serde::__private::Result<Self, __D::Error>
1584 where
1585 __D: _serde::Deserializer<'de>,
1586 {
1587 _serde::Deserializer::deserialize_identifier(
1588 __deserializer,
1589 _serde::de::ReadEnumSize::Uint8,
1590 __FieldVisitor,
1591 )
1592 }
1593 }
1594 #[doc(hidden)]
1595 struct __Visitor<'de> {
1596 marker: _serde::__private::PhantomData<ScalarQuantization>,
1597 lifetime: _serde::__private::PhantomData<&'de ()>,
1598 }
1599 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1600 type Value = ScalarQuantization;
1601 fn expecting(
1602 &self,
1603 __formatter: &mut _serde::__private::Formatter,
1604 ) -> _serde::__private::fmt::Result {
1605 _serde::__private::Formatter::write_str(
1606 __formatter,
1607 "enum ScalarQuantization",
1608 )
1609 }
1610 fn visit_enum<__A>(
1611 self,
1612 __data: __A,
1613 ) -> _serde::__private::Result<Self::Value, __A::Error>
1614 where
1615 __A: _serde::de::EnumAccess<'de>,
1616 {
1617 match _serde::de::EnumAccess::variant(__data)? {
1618 (__Field::__field0, __variant) => {
1619 _serde::de::VariantAccess::unit_variant(__variant)?;
1620 _serde::__private::Ok(ScalarQuantization::BITS8)
1621 }
1622 (__Field::__field1, __variant) => {
1623 _serde::de::VariantAccess::unit_variant(__variant)?;
1624 _serde::__private::Ok(ScalarQuantization::BITS16)
1625 }
1626 }
1627 }
1628 }
1629 #[doc(hidden)]
1630 const VARIANTS: &'static [&'static str] = &["BITS8", "BITS16"];
1631 _serde::Deserializer::deserialize_enum(
1632 __deserializer,
1633 "ScalarQuantization",
1634 VARIANTS,
1635 __Visitor {
1636 marker: _serde::__private::PhantomData::<ScalarQuantization>,
1637 lifetime: _serde::__private::PhantomData,
1638 },
1639 )
1640 }
1641 }
1642};