havok_classes/generated/
hkbBlendingTransitionEffectInternalState_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbBlendingTransitionEffectInternalState`
5/// - version: `0`
6/// - signature: `0xb18c70c2`
7/// - size: ` 32`(x86)/` 48`(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 hkbBlendingTransitionEffectInternalState {
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: `characterPoseAtBeginningOfTransition`(ctype: `hkArray<hkQsTransform>`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: ` 12`(x86)/` 16`(x86_64)
34    #[cfg_attr(
35        feature = "json_schema",
36        schemars(rename = "characterPoseAtBeginningOfTransition")
37    )]
38    #[cfg_attr(
39        feature = "serde",
40        serde(rename = "characterPoseAtBeginningOfTransition")
41    )]
42    pub m_characterPoseAtBeginningOfTransition: Vec<QsTransform>,
43    /// # C++ Info
44    /// - name: `timeRemaining`(ctype: `hkReal`)
45    /// - offset: ` 20`(x86)/` 32`(x86_64)
46    /// - type_size: `  4`(x86)/`  4`(x86_64)
47    #[cfg_attr(feature = "json_schema", schemars(rename = "timeRemaining"))]
48    #[cfg_attr(feature = "serde", serde(rename = "timeRemaining"))]
49    pub m_timeRemaining: f32,
50    /// # C++ Info
51    /// - name: `timeInTransition`(ctype: `hkReal`)
52    /// - offset: ` 24`(x86)/` 36`(x86_64)
53    /// - type_size: `  4`(x86)/`  4`(x86_64)
54    #[cfg_attr(feature = "json_schema", schemars(rename = "timeInTransition"))]
55    #[cfg_attr(feature = "serde", serde(rename = "timeInTransition"))]
56    pub m_timeInTransition: f32,
57    /// # C++ Info
58    /// - name: `applySelfTransition`(ctype: `hkBool`)
59    /// - offset: ` 28`(x86)/` 40`(x86_64)
60    /// - type_size: `  1`(x86)/`  1`(x86_64)
61    #[cfg_attr(feature = "json_schema", schemars(rename = "applySelfTransition"))]
62    #[cfg_attr(feature = "serde", serde(rename = "applySelfTransition"))]
63    pub m_applySelfTransition: bool,
64    /// # C++ Info
65    /// - name: `initializeCharacterPose`(ctype: `hkBool`)
66    /// - offset: ` 29`(x86)/` 41`(x86_64)
67    /// - type_size: `  1`(x86)/`  1`(x86_64)
68    #[cfg_attr(feature = "json_schema", schemars(rename = "initializeCharacterPose"))]
69    #[cfg_attr(feature = "serde", serde(rename = "initializeCharacterPose"))]
70    pub m_initializeCharacterPose: bool,
71}
72const _: () = {
73    use havok_serde as _serde;
74    impl _serde::HavokClass for hkbBlendingTransitionEffectInternalState {
75        #[inline]
76        fn name(&self) -> &'static str {
77            "hkbBlendingTransitionEffectInternalState"
78        }
79        #[inline]
80        fn signature(&self) -> _serde::__private::Signature {
81            _serde::__private::Signature::new(0xb18c70c2)
82        }
83        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
84        fn deps_indexes(&self) -> Vec<usize> {
85            let mut v = Vec::new();
86            v
87        }
88    }
89    impl _serde::Serialize for hkbBlendingTransitionEffectInternalState {
90        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
91        where
92            S: _serde::ser::Serializer,
93        {
94            let class_meta = self
95                .__ptr
96                .map(|name| (name, _serde::__private::Signature::new(0xb18c70c2)));
97            let mut serializer = __serializer
98                .serialize_struct(
99                    "hkbBlendingTransitionEffectInternalState",
100                    class_meta,
101                    (32u64, 48u64),
102                )?;
103            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
104            serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
105            serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
106            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
107            serializer
108                .serialize_array_field(
109                    "characterPoseAtBeginningOfTransition",
110                    &self.m_characterPoseAtBeginningOfTransition,
111                    TypeSize::NonPtr,
112                )?;
113            serializer.serialize_field("timeRemaining", &self.m_timeRemaining)?;
114            serializer.serialize_field("timeInTransition", &self.m_timeInTransition)?;
115            serializer
116                .serialize_field("applySelfTransition", &self.m_applySelfTransition)?;
117            serializer
118                .serialize_field(
119                    "initializeCharacterPose",
120                    &self.m_initializeCharacterPose,
121                )?;
122            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 6usize].as_slice())?;
123            serializer.end()
124        }
125    }
126};
127#[doc(hidden)]
128#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
129const _: () = {
130    use havok_serde as _serde;
131    #[automatically_derived]
132    impl<'de> _serde::Deserialize<'de> for hkbBlendingTransitionEffectInternalState {
133        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
134        where
135            __D: _serde::Deserializer<'de>,
136        {
137            #[allow(non_camel_case_types)]
138            enum __Field {
139                m_characterPoseAtBeginningOfTransition,
140                m_timeRemaining,
141                m_timeInTransition,
142                m_applySelfTransition,
143                m_initializeCharacterPose,
144                __ignore,
145            }
146            struct __FieldVisitor;
147            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
148                type Value = __Field;
149                fn expecting(
150                    &self,
151                    __formatter: &mut core::fmt::Formatter,
152                ) -> core::fmt::Result {
153                    core::fmt::Formatter::write_str(__formatter, "field identifier")
154                }
155                /// Intended for use in XML.
156                #[allow(clippy::match_single_binding)]
157                #[allow(clippy::reversed_empty_ranges)]
158                #[allow(clippy::single_match)]
159                fn visit_key<__E>(
160                    self,
161                    __value: &str,
162                ) -> core::result::Result<Self::Value, __E>
163                where
164                    __E: _serde::de::Error,
165                {
166                    match __value {
167                        "characterPoseAtBeginningOfTransition" => {
168                            Ok(__Field::m_characterPoseAtBeginningOfTransition)
169                        }
170                        "timeRemaining" => Ok(__Field::m_timeRemaining),
171                        "timeInTransition" => Ok(__Field::m_timeInTransition),
172                        "applySelfTransition" => Ok(__Field::m_applySelfTransition),
173                        "initializeCharacterPose" => {
174                            Ok(__Field::m_initializeCharacterPose)
175                        }
176                        _ => Ok(__Field::__ignore),
177                    }
178                }
179            }
180            impl<'de> _serde::Deserialize<'de> for __Field {
181                #[inline]
182                fn deserialize<__D>(
183                    __deserializer: __D,
184                ) -> core::result::Result<Self, __D::Error>
185                where
186                    __D: _serde::Deserializer<'de>,
187                {
188                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
189                }
190            }
191            struct __hkbBlendingTransitionEffectInternalStateVisitor<'de> {
192                marker: _serde::__private::PhantomData<
193                    hkbBlendingTransitionEffectInternalState,
194                >,
195                lifetime: _serde::__private::PhantomData<&'de ()>,
196            }
197            #[allow(clippy::match_single_binding)]
198            #[allow(clippy::reversed_empty_ranges)]
199            #[allow(clippy::single_match)]
200            impl<'de> _serde::de::Visitor<'de>
201            for __hkbBlendingTransitionEffectInternalStateVisitor<'de> {
202                type Value = hkbBlendingTransitionEffectInternalState;
203                fn expecting(
204                    &self,
205                    __formatter: &mut core::fmt::Formatter,
206                ) -> core::fmt::Result {
207                    core::fmt::Formatter::write_str(
208                        __formatter,
209                        "struct hkbBlendingTransitionEffectInternalState",
210                    )
211                }
212                fn visit_struct_for_bytes<__A>(
213                    self,
214                    mut __map: __A,
215                ) -> _serde::__private::Result<Self::Value, __A::Error>
216                where
217                    __A: _serde::de::MapAccess<'de>,
218                {
219                    let __ptr = __A::class_ptr(&mut __map);
220                    let parent = __A::parent_value(&mut __map)?;
221                    let mut m_characterPoseAtBeginningOfTransition: _serde::__private::Option<
222                        Vec<QsTransform>,
223                    > = _serde::__private::None;
224                    let mut m_timeRemaining: _serde::__private::Option<f32> = _serde::__private::None;
225                    let mut m_timeInTransition: _serde::__private::Option<f32> = _serde::__private::None;
226                    let mut m_applySelfTransition: _serde::__private::Option<bool> = _serde::__private::None;
227                    let mut m_initializeCharacterPose: _serde::__private::Option<bool> = _serde::__private::None;
228                    for i in 0..5usize {
229                        match i {
230                            0usize => {
231                                if _serde::__private::Option::is_some(
232                                    &m_characterPoseAtBeginningOfTransition,
233                                ) {
234                                    return _serde::__private::Err(
235                                        <__A::Error as _serde::de::Error>::duplicate_field(
236                                            "characterPoseAtBeginningOfTransition",
237                                        ),
238                                    );
239                                }
240                                m_characterPoseAtBeginningOfTransition = _serde::__private::Some(
241                                    match __A::next_value::<Vec<QsTransform>>(&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_timeRemaining) {
251                                    return _serde::__private::Err(
252                                        <__A::Error as _serde::de::Error>::duplicate_field(
253                                            "timeRemaining",
254                                        ),
255                                    );
256                                }
257                                m_timeRemaining = _serde::__private::Some(
258                                    match __A::next_value::<f32>(&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(&m_timeInTransition) {
268                                    return _serde::__private::Err(
269                                        <__A::Error as _serde::de::Error>::duplicate_field(
270                                            "timeInTransition",
271                                        ),
272                                    );
273                                }
274                                m_timeInTransition = _serde::__private::Some(
275                                    match __A::next_value::<f32>(&mut __map) {
276                                        _serde::__private::Ok(__val) => __val,
277                                        _serde::__private::Err(__err) => {
278                                            return _serde::__private::Err(__err);
279                                        }
280                                    },
281                                );
282                            }
283                            3usize => {
284                                if _serde::__private::Option::is_some(
285                                    &m_applySelfTransition,
286                                ) {
287                                    return _serde::__private::Err(
288                                        <__A::Error as _serde::de::Error>::duplicate_field(
289                                            "applySelfTransition",
290                                        ),
291                                    );
292                                }
293                                m_applySelfTransition = _serde::__private::Some(
294                                    match __A::next_value::<bool>(&mut __map) {
295                                        _serde::__private::Ok(__val) => __val,
296                                        _serde::__private::Err(__err) => {
297                                            return _serde::__private::Err(__err);
298                                        }
299                                    },
300                                );
301                            }
302                            4usize => {
303                                if _serde::__private::Option::is_some(
304                                    &m_initializeCharacterPose,
305                                ) {
306                                    return _serde::__private::Err(
307                                        <__A::Error as _serde::de::Error>::duplicate_field(
308                                            "initializeCharacterPose",
309                                        ),
310                                    );
311                                }
312                                m_initializeCharacterPose = _serde::__private::Some(
313                                    match __A::next_value::<bool>(&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, 2usize, 6usize)?;
325                    let m_characterPoseAtBeginningOfTransition = match m_characterPoseAtBeginningOfTransition {
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                                    "characterPoseAtBeginningOfTransition",
331                                ),
332                            );
333                        }
334                    };
335                    let m_timeRemaining = match m_timeRemaining {
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                                    "timeRemaining",
341                                ),
342                            );
343                        }
344                    };
345                    let m_timeInTransition = match m_timeInTransition {
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                                    "timeInTransition",
351                                ),
352                            );
353                        }
354                    };
355                    let m_applySelfTransition = match m_applySelfTransition {
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                                    "applySelfTransition",
361                                ),
362                            );
363                        }
364                    };
365                    let m_initializeCharacterPose = match m_initializeCharacterPose {
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                                    "initializeCharacterPose",
371                                ),
372                            );
373                        }
374                    };
375                    _serde::__private::Ok(hkbBlendingTransitionEffectInternalState {
376                        __ptr,
377                        parent,
378                        m_characterPoseAtBeginningOfTransition,
379                        m_timeRemaining,
380                        m_timeInTransition,
381                        m_applySelfTransition,
382                        m_initializeCharacterPose,
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_characterPoseAtBeginningOfTransition: _serde::__private::Option<
394                        Vec<QsTransform>,
395                    > = _serde::__private::None;
396                    let mut m_timeRemaining: _serde::__private::Option<f32> = _serde::__private::None;
397                    let mut m_timeInTransition: _serde::__private::Option<f32> = _serde::__private::None;
398                    let mut m_applySelfTransition: _serde::__private::Option<bool> = _serde::__private::None;
399                    let mut m_initializeCharacterPose: _serde::__private::Option<bool> = _serde::__private::None;
400                    while let _serde::__private::Some(__key) = {
401                        __A::next_key::<__Field>(&mut __map)?
402                    } {
403                        match __key {
404                            __Field::m_characterPoseAtBeginningOfTransition => {
405                                #[cfg(
406                                    any(feature = "strict", feature = "ignore_duplicates")
407                                )]
408                                if _serde::__private::Option::is_some(
409                                    &m_characterPoseAtBeginningOfTransition,
410                                ) {
411                                    #[cfg(feature = "ignore_duplicates")]
412                                    {
413                                        __A::skip_value(&mut __map)?;
414                                        continue;
415                                    }
416                                    #[cfg(feature = "strict")]
417                                    return _serde::__private::Err(
418                                        <__A::Error as _serde::de::Error>::duplicate_field(
419                                            "characterPoseAtBeginningOfTransition",
420                                        ),
421                                    );
422                                }
423                                m_characterPoseAtBeginningOfTransition = _serde::__private::Some(
424                                    match __A::next_value::<Vec<QsTransform>>(&mut __map) {
425                                        _serde::__private::Ok(__val) => __val,
426                                        _serde::__private::Err(__err) => {
427                                            return _serde::__private::Err(__err);
428                                        }
429                                    },
430                                );
431                            }
432                            __Field::m_timeRemaining => {
433                                #[cfg(
434                                    any(feature = "strict", feature = "ignore_duplicates")
435                                )]
436                                if _serde::__private::Option::is_some(&m_timeRemaining) {
437                                    #[cfg(feature = "ignore_duplicates")]
438                                    {
439                                        __A::skip_value(&mut __map)?;
440                                        continue;
441                                    }
442                                    #[cfg(feature = "strict")]
443                                    return _serde::__private::Err(
444                                        <__A::Error as _serde::de::Error>::duplicate_field(
445                                            "timeRemaining",
446                                        ),
447                                    );
448                                }
449                                m_timeRemaining = _serde::__private::Some(
450                                    match __A::next_value::<f32>(&mut __map) {
451                                        _serde::__private::Ok(__val) => __val,
452                                        _serde::__private::Err(__err) => {
453                                            return _serde::__private::Err(__err);
454                                        }
455                                    },
456                                );
457                            }
458                            __Field::m_timeInTransition => {
459                                #[cfg(
460                                    any(feature = "strict", feature = "ignore_duplicates")
461                                )]
462                                if _serde::__private::Option::is_some(&m_timeInTransition) {
463                                    #[cfg(feature = "ignore_duplicates")]
464                                    {
465                                        __A::skip_value(&mut __map)?;
466                                        continue;
467                                    }
468                                    #[cfg(feature = "strict")]
469                                    return _serde::__private::Err(
470                                        <__A::Error as _serde::de::Error>::duplicate_field(
471                                            "timeInTransition",
472                                        ),
473                                    );
474                                }
475                                m_timeInTransition = _serde::__private::Some(
476                                    match __A::next_value::<f32>(&mut __map) {
477                                        _serde::__private::Ok(__val) => __val,
478                                        _serde::__private::Err(__err) => {
479                                            return _serde::__private::Err(__err);
480                                        }
481                                    },
482                                );
483                            }
484                            __Field::m_applySelfTransition => {
485                                #[cfg(
486                                    any(feature = "strict", feature = "ignore_duplicates")
487                                )]
488                                if _serde::__private::Option::is_some(
489                                    &m_applySelfTransition,
490                                ) {
491                                    #[cfg(feature = "ignore_duplicates")]
492                                    {
493                                        __A::skip_value(&mut __map)?;
494                                        continue;
495                                    }
496                                    #[cfg(feature = "strict")]
497                                    return _serde::__private::Err(
498                                        <__A::Error as _serde::de::Error>::duplicate_field(
499                                            "applySelfTransition",
500                                        ),
501                                    );
502                                }
503                                m_applySelfTransition = _serde::__private::Some(
504                                    match __A::next_value::<bool>(&mut __map) {
505                                        _serde::__private::Ok(__val) => __val,
506                                        _serde::__private::Err(__err) => {
507                                            return _serde::__private::Err(__err);
508                                        }
509                                    },
510                                );
511                            }
512                            __Field::m_initializeCharacterPose => {
513                                #[cfg(
514                                    any(feature = "strict", feature = "ignore_duplicates")
515                                )]
516                                if _serde::__private::Option::is_some(
517                                    &m_initializeCharacterPose,
518                                ) {
519                                    #[cfg(feature = "ignore_duplicates")]
520                                    {
521                                        __A::skip_value(&mut __map)?;
522                                        continue;
523                                    }
524                                    #[cfg(feature = "strict")]
525                                    return _serde::__private::Err(
526                                        <__A::Error as _serde::de::Error>::duplicate_field(
527                                            "initializeCharacterPose",
528                                        ),
529                                    );
530                                }
531                                m_initializeCharacterPose = _serde::__private::Some(
532                                    match __A::next_value::<bool>(&mut __map) {
533                                        _serde::__private::Ok(__val) => __val,
534                                        _serde::__private::Err(__err) => {
535                                            return _serde::__private::Err(__err);
536                                        }
537                                    },
538                                );
539                            }
540                            _ => __A::skip_value(&mut __map)?,
541                        }
542                    }
543                    let m_characterPoseAtBeginningOfTransition = match m_characterPoseAtBeginningOfTransition {
544                        _serde::__private::Some(__field) => __field,
545                        _serde::__private::None => {
546                            #[cfg(feature = "strict")]
547                            return _serde::__private::Err(
548                                <__A::Error as _serde::de::Error>::missing_field(
549                                    "characterPoseAtBeginningOfTransition",
550                                ),
551                            );
552                            #[cfg(not(feature = "strict"))] Default::default()
553                        }
554                    };
555                    let m_timeRemaining = match m_timeRemaining {
556                        _serde::__private::Some(__field) => __field,
557                        _serde::__private::None => {
558                            #[cfg(feature = "strict")]
559                            return _serde::__private::Err(
560                                <__A::Error as _serde::de::Error>::missing_field(
561                                    "timeRemaining",
562                                ),
563                            );
564                            #[cfg(not(feature = "strict"))] Default::default()
565                        }
566                    };
567                    let m_timeInTransition = match m_timeInTransition {
568                        _serde::__private::Some(__field) => __field,
569                        _serde::__private::None => {
570                            #[cfg(feature = "strict")]
571                            return _serde::__private::Err(
572                                <__A::Error as _serde::de::Error>::missing_field(
573                                    "timeInTransition",
574                                ),
575                            );
576                            #[cfg(not(feature = "strict"))] Default::default()
577                        }
578                    };
579                    let m_applySelfTransition = match m_applySelfTransition {
580                        _serde::__private::Some(__field) => __field,
581                        _serde::__private::None => {
582                            #[cfg(feature = "strict")]
583                            return _serde::__private::Err(
584                                <__A::Error as _serde::de::Error>::missing_field(
585                                    "applySelfTransition",
586                                ),
587                            );
588                            #[cfg(not(feature = "strict"))] Default::default()
589                        }
590                    };
591                    let m_initializeCharacterPose = match m_initializeCharacterPose {
592                        _serde::__private::Some(__field) => __field,
593                        _serde::__private::None => {
594                            #[cfg(feature = "strict")]
595                            return _serde::__private::Err(
596                                <__A::Error as _serde::de::Error>::missing_field(
597                                    "initializeCharacterPose",
598                                ),
599                            );
600                            #[cfg(not(feature = "strict"))] Default::default()
601                        }
602                    };
603                    let __ptr = None;
604                    let parent = hkBaseObject { __ptr };
605                    let parent = hkReferencedObject {
606                        __ptr,
607                        parent,
608                        ..Default::default()
609                    };
610                    let __ptr = __A::class_ptr(&mut __map);
611                    _serde::__private::Ok(hkbBlendingTransitionEffectInternalState {
612                        __ptr,
613                        parent,
614                        m_characterPoseAtBeginningOfTransition,
615                        m_timeRemaining,
616                        m_timeInTransition,
617                        m_applySelfTransition,
618                        m_initializeCharacterPose,
619                    })
620                }
621            }
622            const FIELDS: &[&str] = &[
623                "characterPoseAtBeginningOfTransition",
624                "timeRemaining",
625                "timeInTransition",
626                "applySelfTransition",
627                "initializeCharacterPose",
628            ];
629            _serde::Deserializer::deserialize_struct(
630                deserializer,
631                "hkbBlendingTransitionEffectInternalState",
632                FIELDS,
633                __hkbBlendingTransitionEffectInternalStateVisitor {
634                    marker: _serde::__private::PhantomData::<
635                        hkbBlendingTransitionEffectInternalState,
636                    >,
637                    lifetime: _serde::__private::PhantomData,
638                },
639            )
640        }
641    }
642};