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 hkaDeltaCompressedAnimationQuantizationFormat {
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 = "maxBitWidth"))]
31 #[cfg_attr(feature = "serde", serde(rename = "maxBitWidth"))]
32 pub m_maxBitWidth: u8,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "preserved"))]
38 #[cfg_attr(feature = "serde", serde(rename = "preserved"))]
39 pub m_preserved: u8,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "numD"))]
45 #[cfg_attr(feature = "serde", serde(rename = "numD"))]
46 pub m_numD: u32,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "offsetIdx"))]
52 #[cfg_attr(feature = "serde", serde(rename = "offsetIdx"))]
53 pub m_offsetIdx: u32,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "scaleIdx"))]
59 #[cfg_attr(feature = "serde", serde(rename = "scaleIdx"))]
60 pub m_scaleIdx: u32,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "bitWidthIdx"))]
66 #[cfg_attr(feature = "serde", serde(rename = "bitWidthIdx"))]
67 pub m_bitWidthIdx: u32,
68}
69const _: () = {
70 use havok_serde as _serde;
71 impl _serde::HavokClass for hkaDeltaCompressedAnimationQuantizationFormat {
72 #[inline]
73 fn name(&self) -> &'static str {
74 "hkaDeltaCompressedAnimationQuantizationFormat"
75 }
76 #[inline]
77 fn signature(&self) -> _serde::__private::Signature {
78 _serde::__private::Signature::new(0x724a7561)
79 }
80 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
81 fn deps_indexes(&self) -> Vec<usize> {
82 let mut v = Vec::new();
83 v
84 }
85 }
86 impl _serde::Serialize for hkaDeltaCompressedAnimationQuantizationFormat {
87 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
88 where
89 S: _serde::ser::Serializer,
90 {
91 let class_meta = self
92 .__ptr
93 .map(|name| (name, _serde::__private::Signature::new(0x724a7561)));
94 let mut serializer = __serializer
95 .serialize_struct(
96 "hkaDeltaCompressedAnimationQuantizationFormat",
97 class_meta,
98 (20u64, 20u64),
99 )?;
100 serializer.serialize_field("maxBitWidth", &self.m_maxBitWidth)?;
101 serializer.serialize_field("preserved", &self.m_preserved)?;
102 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
103 serializer.serialize_field("numD", &self.m_numD)?;
104 serializer.serialize_field("offsetIdx", &self.m_offsetIdx)?;
105 serializer.serialize_field("scaleIdx", &self.m_scaleIdx)?;
106 serializer.serialize_field("bitWidthIdx", &self.m_bitWidthIdx)?;
107 serializer.end()
108 }
109 }
110};
111#[doc(hidden)]
112#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
113const _: () = {
114 use havok_serde as _serde;
115 #[automatically_derived]
116 impl<'de> _serde::Deserialize<'de>
117 for hkaDeltaCompressedAnimationQuantizationFormat {
118 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
119 where
120 __D: _serde::Deserializer<'de>,
121 {
122 #[allow(non_camel_case_types)]
123 enum __Field {
124 m_maxBitWidth,
125 m_preserved,
126 m_numD,
127 m_offsetIdx,
128 m_scaleIdx,
129 m_bitWidthIdx,
130 __ignore,
131 }
132 struct __FieldVisitor;
133 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
134 type Value = __Field;
135 fn expecting(
136 &self,
137 __formatter: &mut core::fmt::Formatter,
138 ) -> core::fmt::Result {
139 core::fmt::Formatter::write_str(__formatter, "field identifier")
140 }
141 #[allow(clippy::match_single_binding)]
143 #[allow(clippy::reversed_empty_ranges)]
144 #[allow(clippy::single_match)]
145 fn visit_key<__E>(
146 self,
147 __value: &str,
148 ) -> core::result::Result<Self::Value, __E>
149 where
150 __E: _serde::de::Error,
151 {
152 match __value {
153 "maxBitWidth" => Ok(__Field::m_maxBitWidth),
154 "preserved" => Ok(__Field::m_preserved),
155 "numD" => Ok(__Field::m_numD),
156 "offsetIdx" => Ok(__Field::m_offsetIdx),
157 "scaleIdx" => Ok(__Field::m_scaleIdx),
158 "bitWidthIdx" => Ok(__Field::m_bitWidthIdx),
159 _ => Ok(__Field::__ignore),
160 }
161 }
162 }
163 impl<'de> _serde::Deserialize<'de> for __Field {
164 #[inline]
165 fn deserialize<__D>(
166 __deserializer: __D,
167 ) -> core::result::Result<Self, __D::Error>
168 where
169 __D: _serde::Deserializer<'de>,
170 {
171 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
172 }
173 }
174 struct __hkaDeltaCompressedAnimationQuantizationFormatVisitor<'de> {
175 marker: _serde::__private::PhantomData<
176 hkaDeltaCompressedAnimationQuantizationFormat,
177 >,
178 lifetime: _serde::__private::PhantomData<&'de ()>,
179 }
180 #[allow(clippy::match_single_binding)]
181 #[allow(clippy::reversed_empty_ranges)]
182 #[allow(clippy::single_match)]
183 impl<'de> _serde::de::Visitor<'de>
184 for __hkaDeltaCompressedAnimationQuantizationFormatVisitor<'de> {
185 type Value = hkaDeltaCompressedAnimationQuantizationFormat;
186 fn expecting(
187 &self,
188 __formatter: &mut core::fmt::Formatter,
189 ) -> core::fmt::Result {
190 core::fmt::Formatter::write_str(
191 __formatter,
192 "struct hkaDeltaCompressedAnimationQuantizationFormat",
193 )
194 }
195 fn visit_struct_for_bytes<__A>(
196 self,
197 mut __map: __A,
198 ) -> _serde::__private::Result<Self::Value, __A::Error>
199 where
200 __A: _serde::de::MapAccess<'de>,
201 {
202 let __ptr = __A::class_ptr(&mut __map);
203 let mut m_maxBitWidth: _serde::__private::Option<u8> = _serde::__private::None;
204 let mut m_preserved: _serde::__private::Option<u8> = _serde::__private::None;
205 let mut m_numD: _serde::__private::Option<u32> = _serde::__private::None;
206 let mut m_offsetIdx: _serde::__private::Option<u32> = _serde::__private::None;
207 let mut m_scaleIdx: _serde::__private::Option<u32> = _serde::__private::None;
208 let mut m_bitWidthIdx: _serde::__private::Option<u32> = _serde::__private::None;
209 for i in 0..6usize {
210 match i {
211 0usize => {
212 if _serde::__private::Option::is_some(&m_maxBitWidth) {
213 return _serde::__private::Err(
214 <__A::Error as _serde::de::Error>::duplicate_field(
215 "maxBitWidth",
216 ),
217 );
218 }
219 m_maxBitWidth = _serde::__private::Some(
220 match __A::next_value::<u8>(&mut __map) {
221 _serde::__private::Ok(__val) => __val,
222 _serde::__private::Err(__err) => {
223 return _serde::__private::Err(__err);
224 }
225 },
226 );
227 }
228 1usize => {
229 if _serde::__private::Option::is_some(&m_preserved) {
230 return _serde::__private::Err(
231 <__A::Error as _serde::de::Error>::duplicate_field(
232 "preserved",
233 ),
234 );
235 }
236 m_preserved = _serde::__private::Some(
237 match __A::next_value::<u8>(&mut __map) {
238 _serde::__private::Ok(__val) => __val,
239 _serde::__private::Err(__err) => {
240 return _serde::__private::Err(__err);
241 }
242 },
243 );
244 }
245 2usize => {
246 if _serde::__private::Option::is_some(&m_numD) {
247 return _serde::__private::Err(
248 <__A::Error as _serde::de::Error>::duplicate_field("numD"),
249 );
250 }
251 __A::pad(&mut __map, 2usize, 2usize)?;
252 m_numD = _serde::__private::Some(
253 match __A::next_value::<u32>(&mut __map) {
254 _serde::__private::Ok(__val) => __val,
255 _serde::__private::Err(__err) => {
256 return _serde::__private::Err(__err);
257 }
258 },
259 );
260 }
261 3usize => {
262 if _serde::__private::Option::is_some(&m_offsetIdx) {
263 return _serde::__private::Err(
264 <__A::Error as _serde::de::Error>::duplicate_field(
265 "offsetIdx",
266 ),
267 );
268 }
269 m_offsetIdx = _serde::__private::Some(
270 match __A::next_value::<u32>(&mut __map) {
271 _serde::__private::Ok(__val) => __val,
272 _serde::__private::Err(__err) => {
273 return _serde::__private::Err(__err);
274 }
275 },
276 );
277 }
278 4usize => {
279 if _serde::__private::Option::is_some(&m_scaleIdx) {
280 return _serde::__private::Err(
281 <__A::Error as _serde::de::Error>::duplicate_field(
282 "scaleIdx",
283 ),
284 );
285 }
286 m_scaleIdx = _serde::__private::Some(
287 match __A::next_value::<u32>(&mut __map) {
288 _serde::__private::Ok(__val) => __val,
289 _serde::__private::Err(__err) => {
290 return _serde::__private::Err(__err);
291 }
292 },
293 );
294 }
295 5usize => {
296 if _serde::__private::Option::is_some(&m_bitWidthIdx) {
297 return _serde::__private::Err(
298 <__A::Error as _serde::de::Error>::duplicate_field(
299 "bitWidthIdx",
300 ),
301 );
302 }
303 m_bitWidthIdx = _serde::__private::Some(
304 match __A::next_value::<u32>(&mut __map) {
305 _serde::__private::Ok(__val) => __val,
306 _serde::__private::Err(__err) => {
307 return _serde::__private::Err(__err);
308 }
309 },
310 );
311 }
312 _ => {}
313 }
314 }
315 let m_maxBitWidth = match m_maxBitWidth {
316 _serde::__private::Some(__field) => __field,
317 _serde::__private::None => {
318 return _serde::__private::Err(
319 <__A::Error as _serde::de::Error>::missing_field(
320 "maxBitWidth",
321 ),
322 );
323 }
324 };
325 let m_preserved = match m_preserved {
326 _serde::__private::Some(__field) => __field,
327 _serde::__private::None => {
328 return _serde::__private::Err(
329 <__A::Error as _serde::de::Error>::missing_field(
330 "preserved",
331 ),
332 );
333 }
334 };
335 let m_numD = match m_numD {
336 _serde::__private::Some(__field) => __field,
337 _serde::__private::None => {
338 return _serde::__private::Err(
339 <__A::Error as _serde::de::Error>::missing_field("numD"),
340 );
341 }
342 };
343 let m_offsetIdx = match m_offsetIdx {
344 _serde::__private::Some(__field) => __field,
345 _serde::__private::None => {
346 return _serde::__private::Err(
347 <__A::Error as _serde::de::Error>::missing_field(
348 "offsetIdx",
349 ),
350 );
351 }
352 };
353 let m_scaleIdx = match m_scaleIdx {
354 _serde::__private::Some(__field) => __field,
355 _serde::__private::None => {
356 return _serde::__private::Err(
357 <__A::Error as _serde::de::Error>::missing_field("scaleIdx"),
358 );
359 }
360 };
361 let m_bitWidthIdx = match m_bitWidthIdx {
362 _serde::__private::Some(__field) => __field,
363 _serde::__private::None => {
364 return _serde::__private::Err(
365 <__A::Error as _serde::de::Error>::missing_field(
366 "bitWidthIdx",
367 ),
368 );
369 }
370 };
371 _serde::__private::Ok(hkaDeltaCompressedAnimationQuantizationFormat {
372 __ptr,
373 m_maxBitWidth,
374 m_preserved,
375 m_numD,
376 m_offsetIdx,
377 m_scaleIdx,
378 m_bitWidthIdx,
379 })
380 }
381 #[allow(clippy::manual_unwrap_or_default)]
382 fn visit_struct<__A>(
383 self,
384 mut __map: __A,
385 ) -> _serde::__private::Result<Self::Value, __A::Error>
386 where
387 __A: _serde::de::MapAccess<'de>,
388 {
389 let mut m_maxBitWidth: _serde::__private::Option<u8> = _serde::__private::None;
390 let mut m_preserved: _serde::__private::Option<u8> = _serde::__private::None;
391 let mut m_numD: _serde::__private::Option<u32> = _serde::__private::None;
392 let mut m_offsetIdx: _serde::__private::Option<u32> = _serde::__private::None;
393 let mut m_scaleIdx: _serde::__private::Option<u32> = _serde::__private::None;
394 let mut m_bitWidthIdx: _serde::__private::Option<u32> = _serde::__private::None;
395 while let _serde::__private::Some(__key) = {
396 __A::next_key::<__Field>(&mut __map)?
397 } {
398 match __key {
399 __Field::m_maxBitWidth => {
400 #[cfg(
401 any(feature = "strict", feature = "ignore_duplicates")
402 )]
403 if _serde::__private::Option::is_some(&m_maxBitWidth) {
404 #[cfg(feature = "ignore_duplicates")]
405 {
406 __A::skip_value(&mut __map)?;
407 continue;
408 }
409 #[cfg(feature = "strict")]
410 return _serde::__private::Err(
411 <__A::Error as _serde::de::Error>::duplicate_field(
412 "maxBitWidth",
413 ),
414 );
415 }
416 m_maxBitWidth = _serde::__private::Some(
417 match __A::next_value::<u8>(&mut __map) {
418 _serde::__private::Ok(__val) => __val,
419 _serde::__private::Err(__err) => {
420 return _serde::__private::Err(__err);
421 }
422 },
423 );
424 }
425 __Field::m_preserved => {
426 #[cfg(
427 any(feature = "strict", feature = "ignore_duplicates")
428 )]
429 if _serde::__private::Option::is_some(&m_preserved) {
430 #[cfg(feature = "ignore_duplicates")]
431 {
432 __A::skip_value(&mut __map)?;
433 continue;
434 }
435 #[cfg(feature = "strict")]
436 return _serde::__private::Err(
437 <__A::Error as _serde::de::Error>::duplicate_field(
438 "preserved",
439 ),
440 );
441 }
442 m_preserved = _serde::__private::Some(
443 match __A::next_value::<u8>(&mut __map) {
444 _serde::__private::Ok(__val) => __val,
445 _serde::__private::Err(__err) => {
446 return _serde::__private::Err(__err);
447 }
448 },
449 );
450 }
451 __Field::m_numD => {
452 #[cfg(
453 any(feature = "strict", feature = "ignore_duplicates")
454 )]
455 if _serde::__private::Option::is_some(&m_numD) {
456 #[cfg(feature = "ignore_duplicates")]
457 {
458 __A::skip_value(&mut __map)?;
459 continue;
460 }
461 #[cfg(feature = "strict")]
462 return _serde::__private::Err(
463 <__A::Error as _serde::de::Error>::duplicate_field("numD"),
464 );
465 }
466 m_numD = _serde::__private::Some(
467 match __A::next_value::<u32>(&mut __map) {
468 _serde::__private::Ok(__val) => __val,
469 _serde::__private::Err(__err) => {
470 return _serde::__private::Err(__err);
471 }
472 },
473 );
474 }
475 __Field::m_offsetIdx => {
476 #[cfg(
477 any(feature = "strict", feature = "ignore_duplicates")
478 )]
479 if _serde::__private::Option::is_some(&m_offsetIdx) {
480 #[cfg(feature = "ignore_duplicates")]
481 {
482 __A::skip_value(&mut __map)?;
483 continue;
484 }
485 #[cfg(feature = "strict")]
486 return _serde::__private::Err(
487 <__A::Error as _serde::de::Error>::duplicate_field(
488 "offsetIdx",
489 ),
490 );
491 }
492 m_offsetIdx = _serde::__private::Some(
493 match __A::next_value::<u32>(&mut __map) {
494 _serde::__private::Ok(__val) => __val,
495 _serde::__private::Err(__err) => {
496 return _serde::__private::Err(__err);
497 }
498 },
499 );
500 }
501 __Field::m_scaleIdx => {
502 #[cfg(
503 any(feature = "strict", feature = "ignore_duplicates")
504 )]
505 if _serde::__private::Option::is_some(&m_scaleIdx) {
506 #[cfg(feature = "ignore_duplicates")]
507 {
508 __A::skip_value(&mut __map)?;
509 continue;
510 }
511 #[cfg(feature = "strict")]
512 return _serde::__private::Err(
513 <__A::Error as _serde::de::Error>::duplicate_field(
514 "scaleIdx",
515 ),
516 );
517 }
518 m_scaleIdx = _serde::__private::Some(
519 match __A::next_value::<u32>(&mut __map) {
520 _serde::__private::Ok(__val) => __val,
521 _serde::__private::Err(__err) => {
522 return _serde::__private::Err(__err);
523 }
524 },
525 );
526 }
527 __Field::m_bitWidthIdx => {
528 #[cfg(
529 any(feature = "strict", feature = "ignore_duplicates")
530 )]
531 if _serde::__private::Option::is_some(&m_bitWidthIdx) {
532 #[cfg(feature = "ignore_duplicates")]
533 {
534 __A::skip_value(&mut __map)?;
535 continue;
536 }
537 #[cfg(feature = "strict")]
538 return _serde::__private::Err(
539 <__A::Error as _serde::de::Error>::duplicate_field(
540 "bitWidthIdx",
541 ),
542 );
543 }
544 m_bitWidthIdx = _serde::__private::Some(
545 match __A::next_value::<u32>(&mut __map) {
546 _serde::__private::Ok(__val) => __val,
547 _serde::__private::Err(__err) => {
548 return _serde::__private::Err(__err);
549 }
550 },
551 );
552 }
553 _ => __A::skip_value(&mut __map)?,
554 }
555 }
556 let m_maxBitWidth = match m_maxBitWidth {
557 _serde::__private::Some(__field) => __field,
558 _serde::__private::None => {
559 #[cfg(feature = "strict")]
560 return _serde::__private::Err(
561 <__A::Error as _serde::de::Error>::missing_field(
562 "maxBitWidth",
563 ),
564 );
565 #[cfg(not(feature = "strict"))] Default::default()
566 }
567 };
568 let m_preserved = match m_preserved {
569 _serde::__private::Some(__field) => __field,
570 _serde::__private::None => {
571 #[cfg(feature = "strict")]
572 return _serde::__private::Err(
573 <__A::Error as _serde::de::Error>::missing_field(
574 "preserved",
575 ),
576 );
577 #[cfg(not(feature = "strict"))] Default::default()
578 }
579 };
580 let m_numD = match m_numD {
581 _serde::__private::Some(__field) => __field,
582 _serde::__private::None => {
583 #[cfg(feature = "strict")]
584 return _serde::__private::Err(
585 <__A::Error as _serde::de::Error>::missing_field("numD"),
586 );
587 #[cfg(not(feature = "strict"))] Default::default()
588 }
589 };
590 let m_offsetIdx = match m_offsetIdx {
591 _serde::__private::Some(__field) => __field,
592 _serde::__private::None => {
593 #[cfg(feature = "strict")]
594 return _serde::__private::Err(
595 <__A::Error as _serde::de::Error>::missing_field(
596 "offsetIdx",
597 ),
598 );
599 #[cfg(not(feature = "strict"))] Default::default()
600 }
601 };
602 let m_scaleIdx = match m_scaleIdx {
603 _serde::__private::Some(__field) => __field,
604 _serde::__private::None => {
605 #[cfg(feature = "strict")]
606 return _serde::__private::Err(
607 <__A::Error as _serde::de::Error>::missing_field("scaleIdx"),
608 );
609 #[cfg(not(feature = "strict"))] Default::default()
610 }
611 };
612 let m_bitWidthIdx = match m_bitWidthIdx {
613 _serde::__private::Some(__field) => __field,
614 _serde::__private::None => {
615 #[cfg(feature = "strict")]
616 return _serde::__private::Err(
617 <__A::Error as _serde::de::Error>::missing_field(
618 "bitWidthIdx",
619 ),
620 );
621 #[cfg(not(feature = "strict"))] Default::default()
622 }
623 };
624 let __ptr = __A::class_ptr(&mut __map);
625 _serde::__private::Ok(hkaDeltaCompressedAnimationQuantizationFormat {
626 __ptr,
627 m_maxBitWidth,
628 m_preserved,
629 m_numD,
630 m_offsetIdx,
631 m_scaleIdx,
632 m_bitWidthIdx,
633 })
634 }
635 }
636 const FIELDS: &[&str] = &[
637 "maxBitWidth",
638 "preserved",
639 "numD",
640 "offsetIdx",
641 "scaleIdx",
642 "bitWidthIdx",
643 ];
644 _serde::Deserializer::deserialize_struct(
645 deserializer,
646 "hkaDeltaCompressedAnimationQuantizationFormat",
647 FIELDS,
648 __hkaDeltaCompressedAnimationQuantizationFormatVisitor {
649 marker: _serde::__private::PhantomData::<
650 hkaDeltaCompressedAnimationQuantizationFormat,
651 >,
652 lifetime: _serde::__private::PhantomData,
653 },
654 )
655 }
656 }
657};