havok_classes/generated/
hkaDeltaCompressedAnimationQuantizationFormat_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkaDeltaCompressedAnimationQuantizationFormat`
5/// - version: `0`
6/// - signature: `0x724a7561`
7/// - size: ` 20`(x86)/` 20`(x86_64)
8/// -  vtable: `false`
9#[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    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// # C++ Info
27    /// - name: `maxBitWidth`(ctype: `hkUint8`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: `  1`(x86)/`  1`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "maxBitWidth"))]
31    #[cfg_attr(feature = "serde", serde(rename = "maxBitWidth"))]
32    pub m_maxBitWidth: u8,
33    /// # C++ Info
34    /// - name: `preserved`(ctype: `hkUint8`)
35    /// - offset: `  1`(x86)/`  1`(x86_64)
36    /// - type_size: `  1`(x86)/`  1`(x86_64)
37    #[cfg_attr(feature = "json_schema", schemars(rename = "preserved"))]
38    #[cfg_attr(feature = "serde", serde(rename = "preserved"))]
39    pub m_preserved: u8,
40    /// # C++ Info
41    /// - name: `numD`(ctype: `hkUint32`)
42    /// - offset: `  4`(x86)/`  4`(x86_64)
43    /// - type_size: `  4`(x86)/`  4`(x86_64)
44    #[cfg_attr(feature = "json_schema", schemars(rename = "numD"))]
45    #[cfg_attr(feature = "serde", serde(rename = "numD"))]
46    pub m_numD: u32,
47    /// # C++ Info
48    /// - name: `offsetIdx`(ctype: `hkUint32`)
49    /// - offset: `  8`(x86)/`  8`(x86_64)
50    /// - type_size: `  4`(x86)/`  4`(x86_64)
51    #[cfg_attr(feature = "json_schema", schemars(rename = "offsetIdx"))]
52    #[cfg_attr(feature = "serde", serde(rename = "offsetIdx"))]
53    pub m_offsetIdx: u32,
54    /// # C++ Info
55    /// - name: `scaleIdx`(ctype: `hkUint32`)
56    /// - offset: ` 12`(x86)/` 12`(x86_64)
57    /// - type_size: `  4`(x86)/`  4`(x86_64)
58    #[cfg_attr(feature = "json_schema", schemars(rename = "scaleIdx"))]
59    #[cfg_attr(feature = "serde", serde(rename = "scaleIdx"))]
60    pub m_scaleIdx: u32,
61    /// # C++ Info
62    /// - name: `bitWidthIdx`(ctype: `hkUint32`)
63    /// - offset: ` 16`(x86)/` 16`(x86_64)
64    /// - type_size: `  4`(x86)/`  4`(x86_64)
65    #[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                /// Intended for use in XML.
142                #[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};