havok_classes/generated/
hkaAnimationBinding_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkaAnimationBinding`
5/// - version: `1`
6/// - signature: `0x66eac971`
7/// - size: ` 44`(x86)/` 72`(x86_64)
8/// -  vtable: `true`
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 hkaAnimationBinding<'a> {
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    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkReferencedObject,
30    /// # C++ Info
31    /// - name: `originalSkeletonName`(ctype: `hkStringPtr`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: `  4`(x86)/`  8`(x86_64)
34    #[cfg_attr(feature = "serde", serde(borrow))]
35    #[cfg_attr(feature = "json_schema", schemars(rename = "originalSkeletonName"))]
36    #[cfg_attr(feature = "serde", serde(rename = "originalSkeletonName"))]
37    pub m_originalSkeletonName: StringPtr<'a>,
38    /// # C++ Info
39    /// - name: `animation`(ctype: `struct hkaAnimation*`)
40    /// - offset: ` 12`(x86)/` 24`(x86_64)
41    /// - type_size: `  4`(x86)/`  8`(x86_64)
42    #[cfg_attr(feature = "json_schema", schemars(rename = "animation"))]
43    #[cfg_attr(feature = "serde", serde(rename = "animation"))]
44    pub m_animation: Pointer,
45    /// # C++ Info
46    /// - name: `transformTrackToBoneIndices`(ctype: `hkArray<hkInt16>`)
47    /// - offset: ` 16`(x86)/` 32`(x86_64)
48    /// - type_size: ` 12`(x86)/` 16`(x86_64)
49    #[cfg_attr(
50        feature = "json_schema",
51        schemars(rename = "transformTrackToBoneIndices")
52    )]
53    #[cfg_attr(feature = "serde", serde(rename = "transformTrackToBoneIndices"))]
54    pub m_transformTrackToBoneIndices: Vec<i16>,
55    /// # C++ Info
56    /// - name: `floatTrackToFloatSlotIndices`(ctype: `hkArray<hkInt16>`)
57    /// - offset: ` 28`(x86)/` 48`(x86_64)
58    /// - type_size: ` 12`(x86)/` 16`(x86_64)
59    #[cfg_attr(
60        feature = "json_schema",
61        schemars(rename = "floatTrackToFloatSlotIndices")
62    )]
63    #[cfg_attr(feature = "serde", serde(rename = "floatTrackToFloatSlotIndices"))]
64    pub m_floatTrackToFloatSlotIndices: Vec<i16>,
65    /// # C++ Info
66    /// - name: `blendHint`(ctype: `enum BlendHint`)
67    /// - offset: ` 40`(x86)/` 64`(x86_64)
68    /// - type_size: `  1`(x86)/`  1`(x86_64)
69    #[cfg_attr(feature = "json_schema", schemars(rename = "blendHint"))]
70    #[cfg_attr(feature = "serde", serde(rename = "blendHint"))]
71    pub m_blendHint: BlendHint,
72}
73const _: () = {
74    use havok_serde as _serde;
75    impl<'a> _serde::HavokClass for hkaAnimationBinding<'a> {
76        #[inline]
77        fn name(&self) -> &'static str {
78            "hkaAnimationBinding"
79        }
80        #[inline]
81        fn signature(&self) -> _serde::__private::Signature {
82            _serde::__private::Signature::new(0x66eac971)
83        }
84        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
85        fn deps_indexes(&self) -> Vec<usize> {
86            let mut v = Vec::new();
87            v.push(self.m_animation.get());
88            v
89        }
90    }
91    impl<'a> _serde::Serialize for hkaAnimationBinding<'a> {
92        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
93        where
94            S: _serde::ser::Serializer,
95        {
96            let class_meta = self
97                .__ptr
98                .map(|name| (name, _serde::__private::Signature::new(0x66eac971)));
99            let mut serializer = __serializer
100                .serialize_struct("hkaAnimationBinding", class_meta, (44u64, 72u64))?;
101            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
102            serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
103            serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
104            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
105            serializer
106                .serialize_field("originalSkeletonName", &self.m_originalSkeletonName)?;
107            serializer.serialize_field("animation", &self.m_animation)?;
108            serializer
109                .serialize_array_field(
110                    "transformTrackToBoneIndices",
111                    &self.m_transformTrackToBoneIndices,
112                    TypeSize::NonPtr,
113                )?;
114            serializer
115                .serialize_array_field(
116                    "floatTrackToFloatSlotIndices",
117                    &self.m_floatTrackToFloatSlotIndices,
118                    TypeSize::NonPtr,
119                )?;
120            serializer.serialize_field("blendHint", &self.m_blendHint)?;
121            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
122            serializer.end()
123        }
124    }
125};
126#[doc(hidden)]
127#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
128const _: () = {
129    use havok_serde as _serde;
130    #[automatically_derived]
131    impl<'de> _serde::Deserialize<'de> for hkaAnimationBinding<'de> {
132        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
133        where
134            __D: _serde::Deserializer<'de>,
135        {
136            #[allow(non_camel_case_types)]
137            enum __Field {
138                m_originalSkeletonName,
139                m_animation,
140                m_transformTrackToBoneIndices,
141                m_floatTrackToFloatSlotIndices,
142                m_blendHint,
143                __ignore,
144            }
145            struct __FieldVisitor;
146            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
147                type Value = __Field;
148                fn expecting(
149                    &self,
150                    __formatter: &mut core::fmt::Formatter,
151                ) -> core::fmt::Result {
152                    core::fmt::Formatter::write_str(__formatter, "field identifier")
153                }
154                /// Intended for use in XML.
155                #[allow(clippy::match_single_binding)]
156                #[allow(clippy::reversed_empty_ranges)]
157                #[allow(clippy::single_match)]
158                fn visit_key<__E>(
159                    self,
160                    __value: &str,
161                ) -> core::result::Result<Self::Value, __E>
162                where
163                    __E: _serde::de::Error,
164                {
165                    match __value {
166                        "originalSkeletonName" => Ok(__Field::m_originalSkeletonName),
167                        "animation" => Ok(__Field::m_animation),
168                        "transformTrackToBoneIndices" => {
169                            Ok(__Field::m_transformTrackToBoneIndices)
170                        }
171                        "floatTrackToFloatSlotIndices" => {
172                            Ok(__Field::m_floatTrackToFloatSlotIndices)
173                        }
174                        "blendHint" => Ok(__Field::m_blendHint),
175                        _ => Ok(__Field::__ignore),
176                    }
177                }
178            }
179            impl<'de> _serde::Deserialize<'de> for __Field {
180                #[inline]
181                fn deserialize<__D>(
182                    __deserializer: __D,
183                ) -> core::result::Result<Self, __D::Error>
184                where
185                    __D: _serde::Deserializer<'de>,
186                {
187                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
188                }
189            }
190            struct __hkaAnimationBindingVisitor<'de> {
191                marker: _serde::__private::PhantomData<hkaAnimationBinding<'de>>,
192                lifetime: _serde::__private::PhantomData<&'de ()>,
193            }
194            #[allow(clippy::match_single_binding)]
195            #[allow(clippy::reversed_empty_ranges)]
196            #[allow(clippy::single_match)]
197            impl<'de> _serde::de::Visitor<'de> for __hkaAnimationBindingVisitor<'de> {
198                type Value = hkaAnimationBinding<'de>;
199                fn expecting(
200                    &self,
201                    __formatter: &mut core::fmt::Formatter,
202                ) -> core::fmt::Result {
203                    core::fmt::Formatter::write_str(
204                        __formatter,
205                        "struct hkaAnimationBinding",
206                    )
207                }
208                fn visit_struct_for_bytes<__A>(
209                    self,
210                    mut __map: __A,
211                ) -> _serde::__private::Result<Self::Value, __A::Error>
212                where
213                    __A: _serde::de::MapAccess<'de>,
214                {
215                    let __ptr = __A::class_ptr(&mut __map);
216                    let parent = __A::parent_value(&mut __map)?;
217                    let mut m_originalSkeletonName: _serde::__private::Option<
218                        StringPtr<'de>,
219                    > = _serde::__private::None;
220                    let mut m_animation: _serde::__private::Option<Pointer> = _serde::__private::None;
221                    let mut m_transformTrackToBoneIndices: _serde::__private::Option<
222                        Vec<i16>,
223                    > = _serde::__private::None;
224                    let mut m_floatTrackToFloatSlotIndices: _serde::__private::Option<
225                        Vec<i16>,
226                    > = _serde::__private::None;
227                    let mut m_blendHint: _serde::__private::Option<BlendHint> = _serde::__private::None;
228                    for i in 0..5usize {
229                        match i {
230                            0usize => {
231                                if _serde::__private::Option::is_some(
232                                    &m_originalSkeletonName,
233                                ) {
234                                    return _serde::__private::Err(
235                                        <__A::Error as _serde::de::Error>::duplicate_field(
236                                            "originalSkeletonName",
237                                        ),
238                                    );
239                                }
240                                m_originalSkeletonName = _serde::__private::Some(
241                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
242                                        _serde::__private::Ok(__val) => __val,
243                                        _serde::__private::Err(__err) => {
244                                            return _serde::__private::Err(__err);
245                                        }
246                                    },
247                                );
248                            }
249                            1usize => {
250                                if _serde::__private::Option::is_some(&m_animation) {
251                                    return _serde::__private::Err(
252                                        <__A::Error as _serde::de::Error>::duplicate_field(
253                                            "animation",
254                                        ),
255                                    );
256                                }
257                                m_animation = _serde::__private::Some(
258                                    match __A::next_value::<Pointer>(&mut __map) {
259                                        _serde::__private::Ok(__val) => __val,
260                                        _serde::__private::Err(__err) => {
261                                            return _serde::__private::Err(__err);
262                                        }
263                                    },
264                                );
265                            }
266                            2usize => {
267                                if _serde::__private::Option::is_some(
268                                    &m_transformTrackToBoneIndices,
269                                ) {
270                                    return _serde::__private::Err(
271                                        <__A::Error as _serde::de::Error>::duplicate_field(
272                                            "transformTrackToBoneIndices",
273                                        ),
274                                    );
275                                }
276                                m_transformTrackToBoneIndices = _serde::__private::Some(
277                                    match __A::next_value::<Vec<i16>>(&mut __map) {
278                                        _serde::__private::Ok(__val) => __val,
279                                        _serde::__private::Err(__err) => {
280                                            return _serde::__private::Err(__err);
281                                        }
282                                    },
283                                );
284                            }
285                            3usize => {
286                                if _serde::__private::Option::is_some(
287                                    &m_floatTrackToFloatSlotIndices,
288                                ) {
289                                    return _serde::__private::Err(
290                                        <__A::Error as _serde::de::Error>::duplicate_field(
291                                            "floatTrackToFloatSlotIndices",
292                                        ),
293                                    );
294                                }
295                                m_floatTrackToFloatSlotIndices = _serde::__private::Some(
296                                    match __A::next_value::<Vec<i16>>(&mut __map) {
297                                        _serde::__private::Ok(__val) => __val,
298                                        _serde::__private::Err(__err) => {
299                                            return _serde::__private::Err(__err);
300                                        }
301                                    },
302                                );
303                            }
304                            4usize => {
305                                if _serde::__private::Option::is_some(&m_blendHint) {
306                                    return _serde::__private::Err(
307                                        <__A::Error as _serde::de::Error>::duplicate_field(
308                                            "blendHint",
309                                        ),
310                                    );
311                                }
312                                m_blendHint = _serde::__private::Some(
313                                    match __A::next_value::<BlendHint>(&mut __map) {
314                                        _serde::__private::Ok(__val) => __val,
315                                        _serde::__private::Err(__err) => {
316                                            return _serde::__private::Err(__err);
317                                        }
318                                    },
319                                );
320                            }
321                            _ => {}
322                        }
323                    }
324                    __A::pad(&mut __map, 3usize, 7usize)?;
325                    let m_originalSkeletonName = match m_originalSkeletonName {
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                                    "originalSkeletonName",
331                                ),
332                            );
333                        }
334                    };
335                    let m_animation = match m_animation {
336                        _serde::__private::Some(__field) => __field,
337                        _serde::__private::None => {
338                            return _serde::__private::Err(
339                                <__A::Error as _serde::de::Error>::missing_field(
340                                    "animation",
341                                ),
342                            );
343                        }
344                    };
345                    let m_transformTrackToBoneIndices = match m_transformTrackToBoneIndices {
346                        _serde::__private::Some(__field) => __field,
347                        _serde::__private::None => {
348                            return _serde::__private::Err(
349                                <__A::Error as _serde::de::Error>::missing_field(
350                                    "transformTrackToBoneIndices",
351                                ),
352                            );
353                        }
354                    };
355                    let m_floatTrackToFloatSlotIndices = match m_floatTrackToFloatSlotIndices {
356                        _serde::__private::Some(__field) => __field,
357                        _serde::__private::None => {
358                            return _serde::__private::Err(
359                                <__A::Error as _serde::de::Error>::missing_field(
360                                    "floatTrackToFloatSlotIndices",
361                                ),
362                            );
363                        }
364                    };
365                    let m_blendHint = match m_blendHint {
366                        _serde::__private::Some(__field) => __field,
367                        _serde::__private::None => {
368                            return _serde::__private::Err(
369                                <__A::Error as _serde::de::Error>::missing_field(
370                                    "blendHint",
371                                ),
372                            );
373                        }
374                    };
375                    _serde::__private::Ok(hkaAnimationBinding {
376                        __ptr,
377                        parent,
378                        m_originalSkeletonName,
379                        m_animation,
380                        m_transformTrackToBoneIndices,
381                        m_floatTrackToFloatSlotIndices,
382                        m_blendHint,
383                    })
384                }
385                #[allow(clippy::manual_unwrap_or_default)]
386                fn visit_struct<__A>(
387                    self,
388                    mut __map: __A,
389                ) -> _serde::__private::Result<Self::Value, __A::Error>
390                where
391                    __A: _serde::de::MapAccess<'de>,
392                {
393                    let mut m_originalSkeletonName: _serde::__private::Option<
394                        StringPtr<'de>,
395                    > = _serde::__private::None;
396                    let mut m_animation: _serde::__private::Option<Pointer> = _serde::__private::None;
397                    let mut m_transformTrackToBoneIndices: _serde::__private::Option<
398                        Vec<i16>,
399                    > = _serde::__private::None;
400                    let mut m_floatTrackToFloatSlotIndices: _serde::__private::Option<
401                        Vec<i16>,
402                    > = _serde::__private::None;
403                    let mut m_blendHint: _serde::__private::Option<BlendHint> = _serde::__private::None;
404                    while let _serde::__private::Some(__key) = {
405                        __A::next_key::<__Field>(&mut __map)?
406                    } {
407                        match __key {
408                            __Field::m_originalSkeletonName => {
409                                #[cfg(
410                                    any(feature = "strict", feature = "ignore_duplicates")
411                                )]
412                                if _serde::__private::Option::is_some(
413                                    &m_originalSkeletonName,
414                                ) {
415                                    #[cfg(feature = "ignore_duplicates")]
416                                    {
417                                        __A::skip_value(&mut __map)?;
418                                        continue;
419                                    }
420                                    #[cfg(feature = "strict")]
421                                    return _serde::__private::Err(
422                                        <__A::Error as _serde::de::Error>::duplicate_field(
423                                            "originalSkeletonName",
424                                        ),
425                                    );
426                                }
427                                m_originalSkeletonName = _serde::__private::Some(
428                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
429                                        _serde::__private::Ok(__val) => __val,
430                                        _serde::__private::Err(__err) => {
431                                            return _serde::__private::Err(__err);
432                                        }
433                                    },
434                                );
435                            }
436                            __Field::m_animation => {
437                                #[cfg(
438                                    any(feature = "strict", feature = "ignore_duplicates")
439                                )]
440                                if _serde::__private::Option::is_some(&m_animation) {
441                                    #[cfg(feature = "ignore_duplicates")]
442                                    {
443                                        __A::skip_value(&mut __map)?;
444                                        continue;
445                                    }
446                                    #[cfg(feature = "strict")]
447                                    return _serde::__private::Err(
448                                        <__A::Error as _serde::de::Error>::duplicate_field(
449                                            "animation",
450                                        ),
451                                    );
452                                }
453                                m_animation = _serde::__private::Some(
454                                    match __A::next_value::<Pointer>(&mut __map) {
455                                        _serde::__private::Ok(__val) => __val,
456                                        _serde::__private::Err(__err) => {
457                                            return _serde::__private::Err(__err);
458                                        }
459                                    },
460                                );
461                            }
462                            __Field::m_transformTrackToBoneIndices => {
463                                #[cfg(
464                                    any(feature = "strict", feature = "ignore_duplicates")
465                                )]
466                                if _serde::__private::Option::is_some(
467                                    &m_transformTrackToBoneIndices,
468                                ) {
469                                    #[cfg(feature = "ignore_duplicates")]
470                                    {
471                                        __A::skip_value(&mut __map)?;
472                                        continue;
473                                    }
474                                    #[cfg(feature = "strict")]
475                                    return _serde::__private::Err(
476                                        <__A::Error as _serde::de::Error>::duplicate_field(
477                                            "transformTrackToBoneIndices",
478                                        ),
479                                    );
480                                }
481                                m_transformTrackToBoneIndices = _serde::__private::Some(
482                                    match __A::next_value::<Vec<i16>>(&mut __map) {
483                                        _serde::__private::Ok(__val) => __val,
484                                        _serde::__private::Err(__err) => {
485                                            return _serde::__private::Err(__err);
486                                        }
487                                    },
488                                );
489                            }
490                            __Field::m_floatTrackToFloatSlotIndices => {
491                                #[cfg(
492                                    any(feature = "strict", feature = "ignore_duplicates")
493                                )]
494                                if _serde::__private::Option::is_some(
495                                    &m_floatTrackToFloatSlotIndices,
496                                ) {
497                                    #[cfg(feature = "ignore_duplicates")]
498                                    {
499                                        __A::skip_value(&mut __map)?;
500                                        continue;
501                                    }
502                                    #[cfg(feature = "strict")]
503                                    return _serde::__private::Err(
504                                        <__A::Error as _serde::de::Error>::duplicate_field(
505                                            "floatTrackToFloatSlotIndices",
506                                        ),
507                                    );
508                                }
509                                m_floatTrackToFloatSlotIndices = _serde::__private::Some(
510                                    match __A::next_value::<Vec<i16>>(&mut __map) {
511                                        _serde::__private::Ok(__val) => __val,
512                                        _serde::__private::Err(__err) => {
513                                            return _serde::__private::Err(__err);
514                                        }
515                                    },
516                                );
517                            }
518                            __Field::m_blendHint => {
519                                #[cfg(
520                                    any(feature = "strict", feature = "ignore_duplicates")
521                                )]
522                                if _serde::__private::Option::is_some(&m_blendHint) {
523                                    #[cfg(feature = "ignore_duplicates")]
524                                    {
525                                        __A::skip_value(&mut __map)?;
526                                        continue;
527                                    }
528                                    #[cfg(feature = "strict")]
529                                    return _serde::__private::Err(
530                                        <__A::Error as _serde::de::Error>::duplicate_field(
531                                            "blendHint",
532                                        ),
533                                    );
534                                }
535                                m_blendHint = _serde::__private::Some(
536                                    match __A::next_value::<BlendHint>(&mut __map) {
537                                        _serde::__private::Ok(__val) => __val,
538                                        _serde::__private::Err(__err) => {
539                                            return _serde::__private::Err(__err);
540                                        }
541                                    },
542                                );
543                            }
544                            _ => __A::skip_value(&mut __map)?,
545                        }
546                    }
547                    let m_originalSkeletonName = match m_originalSkeletonName {
548                        _serde::__private::Some(__field) => __field,
549                        _serde::__private::None => {
550                            #[cfg(feature = "strict")]
551                            return _serde::__private::Err(
552                                <__A::Error as _serde::de::Error>::missing_field(
553                                    "originalSkeletonName",
554                                ),
555                            );
556                            #[cfg(not(feature = "strict"))] Default::default()
557                        }
558                    };
559                    let m_animation = match m_animation {
560                        _serde::__private::Some(__field) => __field,
561                        _serde::__private::None => {
562                            #[cfg(feature = "strict")]
563                            return _serde::__private::Err(
564                                <__A::Error as _serde::de::Error>::missing_field(
565                                    "animation",
566                                ),
567                            );
568                            #[cfg(not(feature = "strict"))] Default::default()
569                        }
570                    };
571                    let m_transformTrackToBoneIndices = match m_transformTrackToBoneIndices {
572                        _serde::__private::Some(__field) => __field,
573                        _serde::__private::None => {
574                            #[cfg(feature = "strict")]
575                            return _serde::__private::Err(
576                                <__A::Error as _serde::de::Error>::missing_field(
577                                    "transformTrackToBoneIndices",
578                                ),
579                            );
580                            #[cfg(not(feature = "strict"))] Default::default()
581                        }
582                    };
583                    let m_floatTrackToFloatSlotIndices = match m_floatTrackToFloatSlotIndices {
584                        _serde::__private::Some(__field) => __field,
585                        _serde::__private::None => {
586                            #[cfg(feature = "strict")]
587                            return _serde::__private::Err(
588                                <__A::Error as _serde::de::Error>::missing_field(
589                                    "floatTrackToFloatSlotIndices",
590                                ),
591                            );
592                            #[cfg(not(feature = "strict"))] Default::default()
593                        }
594                    };
595                    let m_blendHint = match m_blendHint {
596                        _serde::__private::Some(__field) => __field,
597                        _serde::__private::None => {
598                            #[cfg(feature = "strict")]
599                            return _serde::__private::Err(
600                                <__A::Error as _serde::de::Error>::missing_field(
601                                    "blendHint",
602                                ),
603                            );
604                            #[cfg(not(feature = "strict"))] Default::default()
605                        }
606                    };
607                    let __ptr = None;
608                    let parent = hkBaseObject { __ptr };
609                    let parent = hkReferencedObject {
610                        __ptr,
611                        parent,
612                        ..Default::default()
613                    };
614                    let __ptr = __A::class_ptr(&mut __map);
615                    _serde::__private::Ok(hkaAnimationBinding {
616                        __ptr,
617                        parent,
618                        m_originalSkeletonName,
619                        m_animation,
620                        m_transformTrackToBoneIndices,
621                        m_floatTrackToFloatSlotIndices,
622                        m_blendHint,
623                    })
624                }
625            }
626            const FIELDS: &[&str] = &[
627                "originalSkeletonName",
628                "animation",
629                "transformTrackToBoneIndices",
630                "floatTrackToFloatSlotIndices",
631                "blendHint",
632            ];
633            _serde::Deserializer::deserialize_struct(
634                deserializer,
635                "hkaAnimationBinding",
636                FIELDS,
637                __hkaAnimationBindingVisitor {
638                    marker: _serde::__private::PhantomData::<hkaAnimationBinding>,
639                    lifetime: _serde::__private::PhantomData,
640                },
641            )
642        }
643    }
644};
645/// # C++ Info
646/// - name: `BlendHint`(ctype: `hkEnum<BlendHint, hkInt8>`)
647#[allow(non_upper_case_globals, non_snake_case)]
648#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
649#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
650#[derive(
651    Debug,
652    Clone,
653    Default,
654    PartialEq,
655    Eq,
656    PartialOrd,
657    Ord,
658    num_derive::ToPrimitive,
659    num_derive::FromPrimitive,
660)]
661pub enum BlendHint {
662    #[default]
663    NORMAL = 0isize,
664    ADDITIVE = 1isize,
665}
666const _: () = {
667    use havok_serde as __serde;
668    impl __serde::Serialize for BlendHint {
669        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
670        where
671            S: __serde::ser::Serializer,
672        {
673            let mut __serializer = __serializer.serialize_enum_flags()?;
674            match self {
675                Self::NORMAL => __serializer.serialize_field("NORMAL", &0u64),
676                Self::ADDITIVE => __serializer.serialize_field("ADDITIVE", &1u64),
677            }?;
678            use num_traits::ToPrimitive as _;
679            let num = self
680                .to_i8()
681                .ok_or(S::Error::custom("Failed enum BlendHint to_i8"))?;
682            __serializer.serialize_bits(&num)?;
683            __serializer.end()
684        }
685    }
686};
687#[doc(hidden)]
688#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
689const _: () = {
690    #[allow(unused_extern_crates, clippy::useless_attribute)]
691    extern crate havok_serde as _serde;
692    #[automatically_derived]
693    impl<'de> _serde::Deserialize<'de> for BlendHint {
694        fn deserialize<__D>(
695            __deserializer: __D,
696        ) -> _serde::__private::Result<Self, __D::Error>
697        where
698            __D: _serde::Deserializer<'de>,
699        {
700            #[allow(non_camel_case_types)]
701            #[doc(hidden)]
702            enum __Field {
703                __field0,
704                __field1,
705            }
706            #[doc(hidden)]
707            struct __FieldVisitor;
708            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
709                type Value = __Field;
710                fn expecting(
711                    &self,
712                    __formatter: &mut _serde::__private::Formatter,
713                ) -> _serde::__private::fmt::Result {
714                    _serde::__private::Formatter::write_str(
715                        __formatter,
716                        "variant identifier",
717                    )
718                }
719                fn visit_int8<__E>(
720                    self,
721                    __value: i8,
722                ) -> _serde::__private::Result<Self::Value, __E>
723                where
724                    __E: _serde::de::Error,
725                {
726                    match __value {
727                        0i8 => _serde::__private::Ok(__Field::__field0),
728                        1i8 => _serde::__private::Ok(__Field::__field1),
729                        _ => {
730                            _serde::__private::Err(
731                                _serde::de::Error::invalid_value(
732                                    _serde::de::Unexpected::Int8(__value),
733                                    &"value(i8) of variant is one of 0, 1",
734                                ),
735                            )
736                        }
737                    }
738                }
739                fn visit_stringptr<__E>(
740                    self,
741                    __value: StringPtr<'de>,
742                ) -> _serde::__private::Result<Self::Value, __E>
743                where
744                    __E: _serde::de::Error,
745                {
746                    if let Some(__value) = __value.into_inner() {
747                        match __value.as_ref() {
748                            v if v == "0" || v.eq_ignore_ascii_case("NORMAL") => {
749                                _serde::__private::Ok(__Field::__field0)
750                            }
751                            v if v == "1" || v.eq_ignore_ascii_case("ADDITIVE") => {
752                                _serde::__private::Ok(__Field::__field1)
753                            }
754                            _ => {
755                                _serde::__private::Err(
756                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
757                                )
758                            }
759                        }
760                    } else {
761                        _serde::__private::Err(
762                            _serde::de::Error::unknown_variant("None", VARIANTS),
763                        )
764                    }
765                }
766            }
767            impl<'de> _serde::Deserialize<'de> for __Field {
768                #[inline]
769                fn deserialize<__D>(
770                    __deserializer: __D,
771                ) -> _serde::__private::Result<Self, __D::Error>
772                where
773                    __D: _serde::Deserializer<'de>,
774                {
775                    _serde::Deserializer::deserialize_identifier(
776                        __deserializer,
777                        _serde::de::ReadEnumSize::Int8,
778                        __FieldVisitor,
779                    )
780                }
781            }
782            #[doc(hidden)]
783            struct __Visitor<'de> {
784                marker: _serde::__private::PhantomData<BlendHint>,
785                lifetime: _serde::__private::PhantomData<&'de ()>,
786            }
787            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
788                type Value = BlendHint;
789                fn expecting(
790                    &self,
791                    __formatter: &mut _serde::__private::Formatter,
792                ) -> _serde::__private::fmt::Result {
793                    _serde::__private::Formatter::write_str(
794                        __formatter,
795                        "enum BlendHint",
796                    )
797                }
798                fn visit_enum<__A>(
799                    self,
800                    __data: __A,
801                ) -> _serde::__private::Result<Self::Value, __A::Error>
802                where
803                    __A: _serde::de::EnumAccess<'de>,
804                {
805                    match _serde::de::EnumAccess::variant(__data)? {
806                        (__Field::__field0, __variant) => {
807                            _serde::de::VariantAccess::unit_variant(__variant)?;
808                            _serde::__private::Ok(BlendHint::NORMAL)
809                        }
810                        (__Field::__field1, __variant) => {
811                            _serde::de::VariantAccess::unit_variant(__variant)?;
812                            _serde::__private::Ok(BlendHint::ADDITIVE)
813                        }
814                    }
815                }
816            }
817            #[doc(hidden)]
818            const VARIANTS: &'static [&'static str] = &["NORMAL", "ADDITIVE"];
819            _serde::Deserializer::deserialize_enum(
820                __deserializer,
821                "BlendHint",
822                VARIANTS,
823                __Visitor {
824                    marker: _serde::__private::PhantomData::<BlendHint>,
825                    lifetime: _serde::__private::PhantomData,
826                },
827            )
828        }
829    }
830};