havok_classes/generated/
hkaSkeletonMapperDataChainMapping_.rs

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