havok_classes/generated/
hkpConstraintChainInstance_.rs

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