havok_classes/generated/
BSIsActiveModifier_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `BSIsActiveModifier`
5/// - version: `1`
6/// - signature: `0xb0fde45a`
7/// - size: ` 56`(x86)/` 96`(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 BSIsActiveModifier<'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: hkbModifier<'a>,
31    /// # C++ Info
32    /// - name: `bIsActive0`(ctype: `hkBool`)
33    /// - offset: ` 44`(x86)/` 80`(x86_64)
34    /// - type_size: `  1`(x86)/`  1`(x86_64)
35    #[cfg_attr(feature = "json_schema", schemars(rename = "bIsActive0"))]
36    #[cfg_attr(feature = "serde", serde(rename = "bIsActive0"))]
37    pub m_bIsActive0: bool,
38    /// # C++ Info
39    /// - name: `bInvertActive0`(ctype: `hkBool`)
40    /// - offset: ` 45`(x86)/` 81`(x86_64)
41    /// - type_size: `  1`(x86)/`  1`(x86_64)
42    #[cfg_attr(feature = "json_schema", schemars(rename = "bInvertActive0"))]
43    #[cfg_attr(feature = "serde", serde(rename = "bInvertActive0"))]
44    pub m_bInvertActive0: bool,
45    /// # C++ Info
46    /// - name: `bIsActive1`(ctype: `hkBool`)
47    /// - offset: ` 46`(x86)/` 82`(x86_64)
48    /// - type_size: `  1`(x86)/`  1`(x86_64)
49    #[cfg_attr(feature = "json_schema", schemars(rename = "bIsActive1"))]
50    #[cfg_attr(feature = "serde", serde(rename = "bIsActive1"))]
51    pub m_bIsActive1: bool,
52    /// # C++ Info
53    /// - name: `bInvertActive1`(ctype: `hkBool`)
54    /// - offset: ` 47`(x86)/` 83`(x86_64)
55    /// - type_size: `  1`(x86)/`  1`(x86_64)
56    #[cfg_attr(feature = "json_schema", schemars(rename = "bInvertActive1"))]
57    #[cfg_attr(feature = "serde", serde(rename = "bInvertActive1"))]
58    pub m_bInvertActive1: bool,
59    /// # C++ Info
60    /// - name: `bIsActive2`(ctype: `hkBool`)
61    /// - offset: ` 48`(x86)/` 84`(x86_64)
62    /// - type_size: `  1`(x86)/`  1`(x86_64)
63    #[cfg_attr(feature = "json_schema", schemars(rename = "bIsActive2"))]
64    #[cfg_attr(feature = "serde", serde(rename = "bIsActive2"))]
65    pub m_bIsActive2: bool,
66    /// # C++ Info
67    /// - name: `bInvertActive2`(ctype: `hkBool`)
68    /// - offset: ` 49`(x86)/` 85`(x86_64)
69    /// - type_size: `  1`(x86)/`  1`(x86_64)
70    #[cfg_attr(feature = "json_schema", schemars(rename = "bInvertActive2"))]
71    #[cfg_attr(feature = "serde", serde(rename = "bInvertActive2"))]
72    pub m_bInvertActive2: bool,
73    /// # C++ Info
74    /// - name: `bIsActive3`(ctype: `hkBool`)
75    /// - offset: ` 50`(x86)/` 86`(x86_64)
76    /// - type_size: `  1`(x86)/`  1`(x86_64)
77    #[cfg_attr(feature = "json_schema", schemars(rename = "bIsActive3"))]
78    #[cfg_attr(feature = "serde", serde(rename = "bIsActive3"))]
79    pub m_bIsActive3: bool,
80    /// # C++ Info
81    /// - name: `bInvertActive3`(ctype: `hkBool`)
82    /// - offset: ` 51`(x86)/` 87`(x86_64)
83    /// - type_size: `  1`(x86)/`  1`(x86_64)
84    #[cfg_attr(feature = "json_schema", schemars(rename = "bInvertActive3"))]
85    #[cfg_attr(feature = "serde", serde(rename = "bInvertActive3"))]
86    pub m_bInvertActive3: bool,
87    /// # C++ Info
88    /// - name: `bIsActive4`(ctype: `hkBool`)
89    /// - offset: ` 52`(x86)/` 88`(x86_64)
90    /// - type_size: `  1`(x86)/`  1`(x86_64)
91    #[cfg_attr(feature = "json_schema", schemars(rename = "bIsActive4"))]
92    #[cfg_attr(feature = "serde", serde(rename = "bIsActive4"))]
93    pub m_bIsActive4: bool,
94    /// # C++ Info
95    /// - name: `bInvertActive4`(ctype: `hkBool`)
96    /// - offset: ` 53`(x86)/` 89`(x86_64)
97    /// - type_size: `  1`(x86)/`  1`(x86_64)
98    #[cfg_attr(feature = "json_schema", schemars(rename = "bInvertActive4"))]
99    #[cfg_attr(feature = "serde", serde(rename = "bInvertActive4"))]
100    pub m_bInvertActive4: bool,
101}
102const _: () = {
103    use havok_serde as _serde;
104    impl<'a> _serde::HavokClass for BSIsActiveModifier<'a> {
105        #[inline]
106        fn name(&self) -> &'static str {
107            "BSIsActiveModifier"
108        }
109        #[inline]
110        fn signature(&self) -> _serde::__private::Signature {
111            _serde::__private::Signature::new(0xb0fde45a)
112        }
113        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
114        fn deps_indexes(&self) -> Vec<usize> {
115            let mut v = Vec::new();
116            v.push(self.parent.parent.parent.m_variableBindingSet.get());
117            v
118        }
119    }
120    impl<'a> _serde::Serialize for BSIsActiveModifier<'a> {
121        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
122        where
123            S: _serde::ser::Serializer,
124        {
125            let class_meta = self
126                .__ptr
127                .map(|name| (name, _serde::__private::Signature::new(0xb0fde45a)));
128            let mut serializer = __serializer
129                .serialize_struct("BSIsActiveModifier", class_meta, (56u64, 96u64))?;
130            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
131            serializer
132                .skip_field(
133                    "memSizeAndFlags",
134                    &self.parent.parent.parent.parent.m_memSizeAndFlags,
135                )?;
136            serializer
137                .skip_field(
138                    "referenceCount",
139                    &self.parent.parent.parent.parent.m_referenceCount,
140                )?;
141            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
142            serializer
143                .serialize_field(
144                    "variableBindingSet",
145                    &self.parent.parent.parent.m_variableBindingSet,
146                )?;
147            serializer
148                .skip_array_field(
149                    "cachedBindables",
150                    &self.parent.parent.parent.m_cachedBindables,
151                    TypeSize::NonPtr,
152                )?;
153            serializer
154                .skip_field(
155                    "areBindablesCached",
156                    &self.parent.parent.parent.m_areBindablesCached,
157                )?;
158            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
159            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
160            serializer.serialize_field("name", &self.parent.parent.m_name)?;
161            serializer.skip_field("id", &self.parent.parent.m_id)?;
162            serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
163            serializer
164                .skip_fixed_array_field(
165                    "padNode",
166                    self.parent.parent.m_padNode.as_slice(),
167                    TypeSize::NonPtr,
168                )?;
169            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
170            serializer.serialize_field("enable", &self.parent.m_enable)?;
171            serializer
172                .skip_fixed_array_field(
173                    "padModifier",
174                    self.parent.m_padModifier.as_slice(),
175                    TypeSize::NonPtr,
176                )?;
177            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
178            serializer.serialize_field("bIsActive0", &self.m_bIsActive0)?;
179            serializer.serialize_field("bInvertActive0", &self.m_bInvertActive0)?;
180            serializer.serialize_field("bIsActive1", &self.m_bIsActive1)?;
181            serializer.serialize_field("bInvertActive1", &self.m_bInvertActive1)?;
182            serializer.serialize_field("bIsActive2", &self.m_bIsActive2)?;
183            serializer.serialize_field("bInvertActive2", &self.m_bInvertActive2)?;
184            serializer.serialize_field("bIsActive3", &self.m_bIsActive3)?;
185            serializer.serialize_field("bInvertActive3", &self.m_bInvertActive3)?;
186            serializer.serialize_field("bIsActive4", &self.m_bIsActive4)?;
187            serializer.serialize_field("bInvertActive4", &self.m_bInvertActive4)?;
188            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 6usize].as_slice())?;
189            serializer.end()
190        }
191    }
192};
193#[doc(hidden)]
194#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
195const _: () = {
196    use havok_serde as _serde;
197    #[automatically_derived]
198    impl<'de> _serde::Deserialize<'de> for BSIsActiveModifier<'de> {
199        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
200        where
201            __D: _serde::Deserializer<'de>,
202        {
203            #[allow(non_camel_case_types)]
204            enum __Field {
205                m_variableBindingSet,
206                m_userData,
207                m_name,
208                m_enable,
209                m_bIsActive0,
210                m_bInvertActive0,
211                m_bIsActive1,
212                m_bInvertActive1,
213                m_bIsActive2,
214                m_bInvertActive2,
215                m_bIsActive3,
216                m_bInvertActive3,
217                m_bIsActive4,
218                m_bInvertActive4,
219                __ignore,
220            }
221            struct __FieldVisitor;
222            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
223                type Value = __Field;
224                fn expecting(
225                    &self,
226                    __formatter: &mut core::fmt::Formatter,
227                ) -> core::fmt::Result {
228                    core::fmt::Formatter::write_str(__formatter, "field identifier")
229                }
230                /// Intended for use in XML.
231                #[allow(clippy::match_single_binding)]
232                #[allow(clippy::reversed_empty_ranges)]
233                #[allow(clippy::single_match)]
234                fn visit_key<__E>(
235                    self,
236                    __value: &str,
237                ) -> core::result::Result<Self::Value, __E>
238                where
239                    __E: _serde::de::Error,
240                {
241                    match __value {
242                        "variableBindingSet" => Ok(__Field::m_variableBindingSet),
243                        "userData" => Ok(__Field::m_userData),
244                        "name" => Ok(__Field::m_name),
245                        "enable" => Ok(__Field::m_enable),
246                        "bIsActive0" => Ok(__Field::m_bIsActive0),
247                        "bInvertActive0" => Ok(__Field::m_bInvertActive0),
248                        "bIsActive1" => Ok(__Field::m_bIsActive1),
249                        "bInvertActive1" => Ok(__Field::m_bInvertActive1),
250                        "bIsActive2" => Ok(__Field::m_bIsActive2),
251                        "bInvertActive2" => Ok(__Field::m_bInvertActive2),
252                        "bIsActive3" => Ok(__Field::m_bIsActive3),
253                        "bInvertActive3" => Ok(__Field::m_bInvertActive3),
254                        "bIsActive4" => Ok(__Field::m_bIsActive4),
255                        "bInvertActive4" => Ok(__Field::m_bInvertActive4),
256                        _ => Ok(__Field::__ignore),
257                    }
258                }
259            }
260            impl<'de> _serde::Deserialize<'de> for __Field {
261                #[inline]
262                fn deserialize<__D>(
263                    __deserializer: __D,
264                ) -> core::result::Result<Self, __D::Error>
265                where
266                    __D: _serde::Deserializer<'de>,
267                {
268                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
269                }
270            }
271            struct __BSIsActiveModifierVisitor<'de> {
272                marker: _serde::__private::PhantomData<BSIsActiveModifier<'de>>,
273                lifetime: _serde::__private::PhantomData<&'de ()>,
274            }
275            #[allow(clippy::match_single_binding)]
276            #[allow(clippy::reversed_empty_ranges)]
277            #[allow(clippy::single_match)]
278            impl<'de> _serde::de::Visitor<'de> for __BSIsActiveModifierVisitor<'de> {
279                type Value = BSIsActiveModifier<'de>;
280                fn expecting(
281                    &self,
282                    __formatter: &mut core::fmt::Formatter,
283                ) -> core::fmt::Result {
284                    core::fmt::Formatter::write_str(
285                        __formatter,
286                        "struct BSIsActiveModifier",
287                    )
288                }
289                fn visit_struct_for_bytes<__A>(
290                    self,
291                    mut __map: __A,
292                ) -> _serde::__private::Result<Self::Value, __A::Error>
293                where
294                    __A: _serde::de::MapAccess<'de>,
295                {
296                    let __ptr = __A::class_ptr(&mut __map);
297                    let parent = __A::parent_value(&mut __map)?;
298                    let mut m_bIsActive0: _serde::__private::Option<bool> = _serde::__private::None;
299                    let mut m_bInvertActive0: _serde::__private::Option<bool> = _serde::__private::None;
300                    let mut m_bIsActive1: _serde::__private::Option<bool> = _serde::__private::None;
301                    let mut m_bInvertActive1: _serde::__private::Option<bool> = _serde::__private::None;
302                    let mut m_bIsActive2: _serde::__private::Option<bool> = _serde::__private::None;
303                    let mut m_bInvertActive2: _serde::__private::Option<bool> = _serde::__private::None;
304                    let mut m_bIsActive3: _serde::__private::Option<bool> = _serde::__private::None;
305                    let mut m_bInvertActive3: _serde::__private::Option<bool> = _serde::__private::None;
306                    let mut m_bIsActive4: _serde::__private::Option<bool> = _serde::__private::None;
307                    let mut m_bInvertActive4: _serde::__private::Option<bool> = _serde::__private::None;
308                    for i in 0..10usize {
309                        match i {
310                            0usize => {
311                                if _serde::__private::Option::is_some(&m_bIsActive0) {
312                                    return _serde::__private::Err(
313                                        <__A::Error as _serde::de::Error>::duplicate_field(
314                                            "bIsActive0",
315                                        ),
316                                    );
317                                }
318                                m_bIsActive0 = _serde::__private::Some(
319                                    match __A::next_value::<bool>(&mut __map) {
320                                        _serde::__private::Ok(__val) => __val,
321                                        _serde::__private::Err(__err) => {
322                                            return _serde::__private::Err(__err);
323                                        }
324                                    },
325                                );
326                            }
327                            1usize => {
328                                if _serde::__private::Option::is_some(&m_bInvertActive0) {
329                                    return _serde::__private::Err(
330                                        <__A::Error as _serde::de::Error>::duplicate_field(
331                                            "bInvertActive0",
332                                        ),
333                                    );
334                                }
335                                m_bInvertActive0 = _serde::__private::Some(
336                                    match __A::next_value::<bool>(&mut __map) {
337                                        _serde::__private::Ok(__val) => __val,
338                                        _serde::__private::Err(__err) => {
339                                            return _serde::__private::Err(__err);
340                                        }
341                                    },
342                                );
343                            }
344                            2usize => {
345                                if _serde::__private::Option::is_some(&m_bIsActive1) {
346                                    return _serde::__private::Err(
347                                        <__A::Error as _serde::de::Error>::duplicate_field(
348                                            "bIsActive1",
349                                        ),
350                                    );
351                                }
352                                m_bIsActive1 = _serde::__private::Some(
353                                    match __A::next_value::<bool>(&mut __map) {
354                                        _serde::__private::Ok(__val) => __val,
355                                        _serde::__private::Err(__err) => {
356                                            return _serde::__private::Err(__err);
357                                        }
358                                    },
359                                );
360                            }
361                            3usize => {
362                                if _serde::__private::Option::is_some(&m_bInvertActive1) {
363                                    return _serde::__private::Err(
364                                        <__A::Error as _serde::de::Error>::duplicate_field(
365                                            "bInvertActive1",
366                                        ),
367                                    );
368                                }
369                                m_bInvertActive1 = _serde::__private::Some(
370                                    match __A::next_value::<bool>(&mut __map) {
371                                        _serde::__private::Ok(__val) => __val,
372                                        _serde::__private::Err(__err) => {
373                                            return _serde::__private::Err(__err);
374                                        }
375                                    },
376                                );
377                            }
378                            4usize => {
379                                if _serde::__private::Option::is_some(&m_bIsActive2) {
380                                    return _serde::__private::Err(
381                                        <__A::Error as _serde::de::Error>::duplicate_field(
382                                            "bIsActive2",
383                                        ),
384                                    );
385                                }
386                                m_bIsActive2 = _serde::__private::Some(
387                                    match __A::next_value::<bool>(&mut __map) {
388                                        _serde::__private::Ok(__val) => __val,
389                                        _serde::__private::Err(__err) => {
390                                            return _serde::__private::Err(__err);
391                                        }
392                                    },
393                                );
394                            }
395                            5usize => {
396                                if _serde::__private::Option::is_some(&m_bInvertActive2) {
397                                    return _serde::__private::Err(
398                                        <__A::Error as _serde::de::Error>::duplicate_field(
399                                            "bInvertActive2",
400                                        ),
401                                    );
402                                }
403                                m_bInvertActive2 = _serde::__private::Some(
404                                    match __A::next_value::<bool>(&mut __map) {
405                                        _serde::__private::Ok(__val) => __val,
406                                        _serde::__private::Err(__err) => {
407                                            return _serde::__private::Err(__err);
408                                        }
409                                    },
410                                );
411                            }
412                            6usize => {
413                                if _serde::__private::Option::is_some(&m_bIsActive3) {
414                                    return _serde::__private::Err(
415                                        <__A::Error as _serde::de::Error>::duplicate_field(
416                                            "bIsActive3",
417                                        ),
418                                    );
419                                }
420                                m_bIsActive3 = _serde::__private::Some(
421                                    match __A::next_value::<bool>(&mut __map) {
422                                        _serde::__private::Ok(__val) => __val,
423                                        _serde::__private::Err(__err) => {
424                                            return _serde::__private::Err(__err);
425                                        }
426                                    },
427                                );
428                            }
429                            7usize => {
430                                if _serde::__private::Option::is_some(&m_bInvertActive3) {
431                                    return _serde::__private::Err(
432                                        <__A::Error as _serde::de::Error>::duplicate_field(
433                                            "bInvertActive3",
434                                        ),
435                                    );
436                                }
437                                m_bInvertActive3 = _serde::__private::Some(
438                                    match __A::next_value::<bool>(&mut __map) {
439                                        _serde::__private::Ok(__val) => __val,
440                                        _serde::__private::Err(__err) => {
441                                            return _serde::__private::Err(__err);
442                                        }
443                                    },
444                                );
445                            }
446                            8usize => {
447                                if _serde::__private::Option::is_some(&m_bIsActive4) {
448                                    return _serde::__private::Err(
449                                        <__A::Error as _serde::de::Error>::duplicate_field(
450                                            "bIsActive4",
451                                        ),
452                                    );
453                                }
454                                m_bIsActive4 = _serde::__private::Some(
455                                    match __A::next_value::<bool>(&mut __map) {
456                                        _serde::__private::Ok(__val) => __val,
457                                        _serde::__private::Err(__err) => {
458                                            return _serde::__private::Err(__err);
459                                        }
460                                    },
461                                );
462                            }
463                            9usize => {
464                                if _serde::__private::Option::is_some(&m_bInvertActive4) {
465                                    return _serde::__private::Err(
466                                        <__A::Error as _serde::de::Error>::duplicate_field(
467                                            "bInvertActive4",
468                                        ),
469                                    );
470                                }
471                                m_bInvertActive4 = _serde::__private::Some(
472                                    match __A::next_value::<bool>(&mut __map) {
473                                        _serde::__private::Ok(__val) => __val,
474                                        _serde::__private::Err(__err) => {
475                                            return _serde::__private::Err(__err);
476                                        }
477                                    },
478                                );
479                            }
480                            _ => {}
481                        }
482                    }
483                    __A::pad(&mut __map, 2usize, 6usize)?;
484                    let m_bIsActive0 = match m_bIsActive0 {
485                        _serde::__private::Some(__field) => __field,
486                        _serde::__private::None => {
487                            return _serde::__private::Err(
488                                <__A::Error as _serde::de::Error>::missing_field(
489                                    "bIsActive0",
490                                ),
491                            );
492                        }
493                    };
494                    let m_bInvertActive0 = match m_bInvertActive0 {
495                        _serde::__private::Some(__field) => __field,
496                        _serde::__private::None => {
497                            return _serde::__private::Err(
498                                <__A::Error as _serde::de::Error>::missing_field(
499                                    "bInvertActive0",
500                                ),
501                            );
502                        }
503                    };
504                    let m_bIsActive1 = match m_bIsActive1 {
505                        _serde::__private::Some(__field) => __field,
506                        _serde::__private::None => {
507                            return _serde::__private::Err(
508                                <__A::Error as _serde::de::Error>::missing_field(
509                                    "bIsActive1",
510                                ),
511                            );
512                        }
513                    };
514                    let m_bInvertActive1 = match m_bInvertActive1 {
515                        _serde::__private::Some(__field) => __field,
516                        _serde::__private::None => {
517                            return _serde::__private::Err(
518                                <__A::Error as _serde::de::Error>::missing_field(
519                                    "bInvertActive1",
520                                ),
521                            );
522                        }
523                    };
524                    let m_bIsActive2 = match m_bIsActive2 {
525                        _serde::__private::Some(__field) => __field,
526                        _serde::__private::None => {
527                            return _serde::__private::Err(
528                                <__A::Error as _serde::de::Error>::missing_field(
529                                    "bIsActive2",
530                                ),
531                            );
532                        }
533                    };
534                    let m_bInvertActive2 = match m_bInvertActive2 {
535                        _serde::__private::Some(__field) => __field,
536                        _serde::__private::None => {
537                            return _serde::__private::Err(
538                                <__A::Error as _serde::de::Error>::missing_field(
539                                    "bInvertActive2",
540                                ),
541                            );
542                        }
543                    };
544                    let m_bIsActive3 = match m_bIsActive3 {
545                        _serde::__private::Some(__field) => __field,
546                        _serde::__private::None => {
547                            return _serde::__private::Err(
548                                <__A::Error as _serde::de::Error>::missing_field(
549                                    "bIsActive3",
550                                ),
551                            );
552                        }
553                    };
554                    let m_bInvertActive3 = match m_bInvertActive3 {
555                        _serde::__private::Some(__field) => __field,
556                        _serde::__private::None => {
557                            return _serde::__private::Err(
558                                <__A::Error as _serde::de::Error>::missing_field(
559                                    "bInvertActive3",
560                                ),
561                            );
562                        }
563                    };
564                    let m_bIsActive4 = match m_bIsActive4 {
565                        _serde::__private::Some(__field) => __field,
566                        _serde::__private::None => {
567                            return _serde::__private::Err(
568                                <__A::Error as _serde::de::Error>::missing_field(
569                                    "bIsActive4",
570                                ),
571                            );
572                        }
573                    };
574                    let m_bInvertActive4 = match m_bInvertActive4 {
575                        _serde::__private::Some(__field) => __field,
576                        _serde::__private::None => {
577                            return _serde::__private::Err(
578                                <__A::Error as _serde::de::Error>::missing_field(
579                                    "bInvertActive4",
580                                ),
581                            );
582                        }
583                    };
584                    _serde::__private::Ok(BSIsActiveModifier {
585                        __ptr,
586                        parent,
587                        m_bIsActive0,
588                        m_bInvertActive0,
589                        m_bIsActive1,
590                        m_bInvertActive1,
591                        m_bIsActive2,
592                        m_bInvertActive2,
593                        m_bIsActive3,
594                        m_bInvertActive3,
595                        m_bIsActive4,
596                        m_bInvertActive4,
597                    })
598                }
599                #[allow(clippy::manual_unwrap_or_default)]
600                fn visit_struct<__A>(
601                    self,
602                    mut __map: __A,
603                ) -> _serde::__private::Result<Self::Value, __A::Error>
604                where
605                    __A: _serde::de::MapAccess<'de>,
606                {
607                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
608                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
609                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
610                    let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
611                    let mut m_bIsActive0: _serde::__private::Option<bool> = _serde::__private::None;
612                    let mut m_bInvertActive0: _serde::__private::Option<bool> = _serde::__private::None;
613                    let mut m_bIsActive1: _serde::__private::Option<bool> = _serde::__private::None;
614                    let mut m_bInvertActive1: _serde::__private::Option<bool> = _serde::__private::None;
615                    let mut m_bIsActive2: _serde::__private::Option<bool> = _serde::__private::None;
616                    let mut m_bInvertActive2: _serde::__private::Option<bool> = _serde::__private::None;
617                    let mut m_bIsActive3: _serde::__private::Option<bool> = _serde::__private::None;
618                    let mut m_bInvertActive3: _serde::__private::Option<bool> = _serde::__private::None;
619                    let mut m_bIsActive4: _serde::__private::Option<bool> = _serde::__private::None;
620                    let mut m_bInvertActive4: _serde::__private::Option<bool> = _serde::__private::None;
621                    while let _serde::__private::Some(__key) = {
622                        __A::next_key::<__Field>(&mut __map)?
623                    } {
624                        match __key {
625                            __Field::m_variableBindingSet => {
626                                #[cfg(
627                                    any(feature = "strict", feature = "ignore_duplicates")
628                                )]
629                                if _serde::__private::Option::is_some(
630                                    &m_variableBindingSet,
631                                ) {
632                                    #[cfg(feature = "ignore_duplicates")]
633                                    {
634                                        __A::skip_value(&mut __map)?;
635                                        continue;
636                                    }
637                                    #[cfg(feature = "strict")]
638                                    return _serde::__private::Err(
639                                        <__A::Error as _serde::de::Error>::duplicate_field(
640                                            "variableBindingSet",
641                                        ),
642                                    );
643                                }
644                                m_variableBindingSet = _serde::__private::Some(
645                                    match __A::next_value::<Pointer>(&mut __map) {
646                                        _serde::__private::Ok(__val) => __val,
647                                        _serde::__private::Err(__err) => {
648                                            return _serde::__private::Err(__err);
649                                        }
650                                    },
651                                );
652                            }
653                            __Field::m_userData => {
654                                #[cfg(
655                                    any(feature = "strict", feature = "ignore_duplicates")
656                                )]
657                                if _serde::__private::Option::is_some(&m_userData) {
658                                    #[cfg(feature = "ignore_duplicates")]
659                                    {
660                                        __A::skip_value(&mut __map)?;
661                                        continue;
662                                    }
663                                    #[cfg(feature = "strict")]
664                                    return _serde::__private::Err(
665                                        <__A::Error as _serde::de::Error>::duplicate_field(
666                                            "userData",
667                                        ),
668                                    );
669                                }
670                                m_userData = _serde::__private::Some(
671                                    match __A::next_value::<Ulong>(&mut __map) {
672                                        _serde::__private::Ok(__val) => __val,
673                                        _serde::__private::Err(__err) => {
674                                            return _serde::__private::Err(__err);
675                                        }
676                                    },
677                                );
678                            }
679                            __Field::m_name => {
680                                #[cfg(
681                                    any(feature = "strict", feature = "ignore_duplicates")
682                                )]
683                                if _serde::__private::Option::is_some(&m_name) {
684                                    #[cfg(feature = "ignore_duplicates")]
685                                    {
686                                        __A::skip_value(&mut __map)?;
687                                        continue;
688                                    }
689                                    #[cfg(feature = "strict")]
690                                    return _serde::__private::Err(
691                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
692                                    );
693                                }
694                                m_name = _serde::__private::Some(
695                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
696                                        _serde::__private::Ok(__val) => __val,
697                                        _serde::__private::Err(__err) => {
698                                            return _serde::__private::Err(__err);
699                                        }
700                                    },
701                                );
702                            }
703                            __Field::m_enable => {
704                                #[cfg(
705                                    any(feature = "strict", feature = "ignore_duplicates")
706                                )]
707                                if _serde::__private::Option::is_some(&m_enable) {
708                                    #[cfg(feature = "ignore_duplicates")]
709                                    {
710                                        __A::skip_value(&mut __map)?;
711                                        continue;
712                                    }
713                                    #[cfg(feature = "strict")]
714                                    return _serde::__private::Err(
715                                        <__A::Error as _serde::de::Error>::duplicate_field("enable"),
716                                    );
717                                }
718                                m_enable = _serde::__private::Some(
719                                    match __A::next_value::<bool>(&mut __map) {
720                                        _serde::__private::Ok(__val) => __val,
721                                        _serde::__private::Err(__err) => {
722                                            return _serde::__private::Err(__err);
723                                        }
724                                    },
725                                );
726                            }
727                            __Field::m_bIsActive0 => {
728                                #[cfg(
729                                    any(feature = "strict", feature = "ignore_duplicates")
730                                )]
731                                if _serde::__private::Option::is_some(&m_bIsActive0) {
732                                    #[cfg(feature = "ignore_duplicates")]
733                                    {
734                                        __A::skip_value(&mut __map)?;
735                                        continue;
736                                    }
737                                    #[cfg(feature = "strict")]
738                                    return _serde::__private::Err(
739                                        <__A::Error as _serde::de::Error>::duplicate_field(
740                                            "bIsActive0",
741                                        ),
742                                    );
743                                }
744                                m_bIsActive0 = _serde::__private::Some(
745                                    match __A::next_value::<bool>(&mut __map) {
746                                        _serde::__private::Ok(__val) => __val,
747                                        _serde::__private::Err(__err) => {
748                                            return _serde::__private::Err(__err);
749                                        }
750                                    },
751                                );
752                            }
753                            __Field::m_bInvertActive0 => {
754                                #[cfg(
755                                    any(feature = "strict", feature = "ignore_duplicates")
756                                )]
757                                if _serde::__private::Option::is_some(&m_bInvertActive0) {
758                                    #[cfg(feature = "ignore_duplicates")]
759                                    {
760                                        __A::skip_value(&mut __map)?;
761                                        continue;
762                                    }
763                                    #[cfg(feature = "strict")]
764                                    return _serde::__private::Err(
765                                        <__A::Error as _serde::de::Error>::duplicate_field(
766                                            "bInvertActive0",
767                                        ),
768                                    );
769                                }
770                                m_bInvertActive0 = _serde::__private::Some(
771                                    match __A::next_value::<bool>(&mut __map) {
772                                        _serde::__private::Ok(__val) => __val,
773                                        _serde::__private::Err(__err) => {
774                                            return _serde::__private::Err(__err);
775                                        }
776                                    },
777                                );
778                            }
779                            __Field::m_bIsActive1 => {
780                                #[cfg(
781                                    any(feature = "strict", feature = "ignore_duplicates")
782                                )]
783                                if _serde::__private::Option::is_some(&m_bIsActive1) {
784                                    #[cfg(feature = "ignore_duplicates")]
785                                    {
786                                        __A::skip_value(&mut __map)?;
787                                        continue;
788                                    }
789                                    #[cfg(feature = "strict")]
790                                    return _serde::__private::Err(
791                                        <__A::Error as _serde::de::Error>::duplicate_field(
792                                            "bIsActive1",
793                                        ),
794                                    );
795                                }
796                                m_bIsActive1 = _serde::__private::Some(
797                                    match __A::next_value::<bool>(&mut __map) {
798                                        _serde::__private::Ok(__val) => __val,
799                                        _serde::__private::Err(__err) => {
800                                            return _serde::__private::Err(__err);
801                                        }
802                                    },
803                                );
804                            }
805                            __Field::m_bInvertActive1 => {
806                                #[cfg(
807                                    any(feature = "strict", feature = "ignore_duplicates")
808                                )]
809                                if _serde::__private::Option::is_some(&m_bInvertActive1) {
810                                    #[cfg(feature = "ignore_duplicates")]
811                                    {
812                                        __A::skip_value(&mut __map)?;
813                                        continue;
814                                    }
815                                    #[cfg(feature = "strict")]
816                                    return _serde::__private::Err(
817                                        <__A::Error as _serde::de::Error>::duplicate_field(
818                                            "bInvertActive1",
819                                        ),
820                                    );
821                                }
822                                m_bInvertActive1 = _serde::__private::Some(
823                                    match __A::next_value::<bool>(&mut __map) {
824                                        _serde::__private::Ok(__val) => __val,
825                                        _serde::__private::Err(__err) => {
826                                            return _serde::__private::Err(__err);
827                                        }
828                                    },
829                                );
830                            }
831                            __Field::m_bIsActive2 => {
832                                #[cfg(
833                                    any(feature = "strict", feature = "ignore_duplicates")
834                                )]
835                                if _serde::__private::Option::is_some(&m_bIsActive2) {
836                                    #[cfg(feature = "ignore_duplicates")]
837                                    {
838                                        __A::skip_value(&mut __map)?;
839                                        continue;
840                                    }
841                                    #[cfg(feature = "strict")]
842                                    return _serde::__private::Err(
843                                        <__A::Error as _serde::de::Error>::duplicate_field(
844                                            "bIsActive2",
845                                        ),
846                                    );
847                                }
848                                m_bIsActive2 = _serde::__private::Some(
849                                    match __A::next_value::<bool>(&mut __map) {
850                                        _serde::__private::Ok(__val) => __val,
851                                        _serde::__private::Err(__err) => {
852                                            return _serde::__private::Err(__err);
853                                        }
854                                    },
855                                );
856                            }
857                            __Field::m_bInvertActive2 => {
858                                #[cfg(
859                                    any(feature = "strict", feature = "ignore_duplicates")
860                                )]
861                                if _serde::__private::Option::is_some(&m_bInvertActive2) {
862                                    #[cfg(feature = "ignore_duplicates")]
863                                    {
864                                        __A::skip_value(&mut __map)?;
865                                        continue;
866                                    }
867                                    #[cfg(feature = "strict")]
868                                    return _serde::__private::Err(
869                                        <__A::Error as _serde::de::Error>::duplicate_field(
870                                            "bInvertActive2",
871                                        ),
872                                    );
873                                }
874                                m_bInvertActive2 = _serde::__private::Some(
875                                    match __A::next_value::<bool>(&mut __map) {
876                                        _serde::__private::Ok(__val) => __val,
877                                        _serde::__private::Err(__err) => {
878                                            return _serde::__private::Err(__err);
879                                        }
880                                    },
881                                );
882                            }
883                            __Field::m_bIsActive3 => {
884                                #[cfg(
885                                    any(feature = "strict", feature = "ignore_duplicates")
886                                )]
887                                if _serde::__private::Option::is_some(&m_bIsActive3) {
888                                    #[cfg(feature = "ignore_duplicates")]
889                                    {
890                                        __A::skip_value(&mut __map)?;
891                                        continue;
892                                    }
893                                    #[cfg(feature = "strict")]
894                                    return _serde::__private::Err(
895                                        <__A::Error as _serde::de::Error>::duplicate_field(
896                                            "bIsActive3",
897                                        ),
898                                    );
899                                }
900                                m_bIsActive3 = _serde::__private::Some(
901                                    match __A::next_value::<bool>(&mut __map) {
902                                        _serde::__private::Ok(__val) => __val,
903                                        _serde::__private::Err(__err) => {
904                                            return _serde::__private::Err(__err);
905                                        }
906                                    },
907                                );
908                            }
909                            __Field::m_bInvertActive3 => {
910                                #[cfg(
911                                    any(feature = "strict", feature = "ignore_duplicates")
912                                )]
913                                if _serde::__private::Option::is_some(&m_bInvertActive3) {
914                                    #[cfg(feature = "ignore_duplicates")]
915                                    {
916                                        __A::skip_value(&mut __map)?;
917                                        continue;
918                                    }
919                                    #[cfg(feature = "strict")]
920                                    return _serde::__private::Err(
921                                        <__A::Error as _serde::de::Error>::duplicate_field(
922                                            "bInvertActive3",
923                                        ),
924                                    );
925                                }
926                                m_bInvertActive3 = _serde::__private::Some(
927                                    match __A::next_value::<bool>(&mut __map) {
928                                        _serde::__private::Ok(__val) => __val,
929                                        _serde::__private::Err(__err) => {
930                                            return _serde::__private::Err(__err);
931                                        }
932                                    },
933                                );
934                            }
935                            __Field::m_bIsActive4 => {
936                                #[cfg(
937                                    any(feature = "strict", feature = "ignore_duplicates")
938                                )]
939                                if _serde::__private::Option::is_some(&m_bIsActive4) {
940                                    #[cfg(feature = "ignore_duplicates")]
941                                    {
942                                        __A::skip_value(&mut __map)?;
943                                        continue;
944                                    }
945                                    #[cfg(feature = "strict")]
946                                    return _serde::__private::Err(
947                                        <__A::Error as _serde::de::Error>::duplicate_field(
948                                            "bIsActive4",
949                                        ),
950                                    );
951                                }
952                                m_bIsActive4 = _serde::__private::Some(
953                                    match __A::next_value::<bool>(&mut __map) {
954                                        _serde::__private::Ok(__val) => __val,
955                                        _serde::__private::Err(__err) => {
956                                            return _serde::__private::Err(__err);
957                                        }
958                                    },
959                                );
960                            }
961                            __Field::m_bInvertActive4 => {
962                                #[cfg(
963                                    any(feature = "strict", feature = "ignore_duplicates")
964                                )]
965                                if _serde::__private::Option::is_some(&m_bInvertActive4) {
966                                    #[cfg(feature = "ignore_duplicates")]
967                                    {
968                                        __A::skip_value(&mut __map)?;
969                                        continue;
970                                    }
971                                    #[cfg(feature = "strict")]
972                                    return _serde::__private::Err(
973                                        <__A::Error as _serde::de::Error>::duplicate_field(
974                                            "bInvertActive4",
975                                        ),
976                                    );
977                                }
978                                m_bInvertActive4 = _serde::__private::Some(
979                                    match __A::next_value::<bool>(&mut __map) {
980                                        _serde::__private::Ok(__val) => __val,
981                                        _serde::__private::Err(__err) => {
982                                            return _serde::__private::Err(__err);
983                                        }
984                                    },
985                                );
986                            }
987                            _ => __A::skip_value(&mut __map)?,
988                        }
989                    }
990                    let m_variableBindingSet = match m_variableBindingSet {
991                        _serde::__private::Some(__field) => __field,
992                        _serde::__private::None => {
993                            #[cfg(feature = "strict")]
994                            return _serde::__private::Err(
995                                <__A::Error as _serde::de::Error>::missing_field(
996                                    "variableBindingSet",
997                                ),
998                            );
999                            #[cfg(not(feature = "strict"))] Default::default()
1000                        }
1001                    };
1002                    let m_userData = match m_userData {
1003                        _serde::__private::Some(__field) => __field,
1004                        _serde::__private::None => {
1005                            #[cfg(feature = "strict")]
1006                            return _serde::__private::Err(
1007                                <__A::Error as _serde::de::Error>::missing_field("userData"),
1008                            );
1009                            #[cfg(not(feature = "strict"))] Default::default()
1010                        }
1011                    };
1012                    let m_name = match m_name {
1013                        _serde::__private::Some(__field) => __field,
1014                        _serde::__private::None => {
1015                            #[cfg(feature = "strict")]
1016                            return _serde::__private::Err(
1017                                <__A::Error as _serde::de::Error>::missing_field("name"),
1018                            );
1019                            #[cfg(not(feature = "strict"))] Default::default()
1020                        }
1021                    };
1022                    let m_enable = match m_enable {
1023                        _serde::__private::Some(__field) => __field,
1024                        _serde::__private::None => {
1025                            #[cfg(feature = "strict")]
1026                            return _serde::__private::Err(
1027                                <__A::Error as _serde::de::Error>::missing_field("enable"),
1028                            );
1029                            #[cfg(not(feature = "strict"))] Default::default()
1030                        }
1031                    };
1032                    let m_bIsActive0 = match m_bIsActive0 {
1033                        _serde::__private::Some(__field) => __field,
1034                        _serde::__private::None => {
1035                            #[cfg(feature = "strict")]
1036                            return _serde::__private::Err(
1037                                <__A::Error as _serde::de::Error>::missing_field(
1038                                    "bIsActive0",
1039                                ),
1040                            );
1041                            #[cfg(not(feature = "strict"))] Default::default()
1042                        }
1043                    };
1044                    let m_bInvertActive0 = match m_bInvertActive0 {
1045                        _serde::__private::Some(__field) => __field,
1046                        _serde::__private::None => {
1047                            #[cfg(feature = "strict")]
1048                            return _serde::__private::Err(
1049                                <__A::Error as _serde::de::Error>::missing_field(
1050                                    "bInvertActive0",
1051                                ),
1052                            );
1053                            #[cfg(not(feature = "strict"))] Default::default()
1054                        }
1055                    };
1056                    let m_bIsActive1 = match m_bIsActive1 {
1057                        _serde::__private::Some(__field) => __field,
1058                        _serde::__private::None => {
1059                            #[cfg(feature = "strict")]
1060                            return _serde::__private::Err(
1061                                <__A::Error as _serde::de::Error>::missing_field(
1062                                    "bIsActive1",
1063                                ),
1064                            );
1065                            #[cfg(not(feature = "strict"))] Default::default()
1066                        }
1067                    };
1068                    let m_bInvertActive1 = match m_bInvertActive1 {
1069                        _serde::__private::Some(__field) => __field,
1070                        _serde::__private::None => {
1071                            #[cfg(feature = "strict")]
1072                            return _serde::__private::Err(
1073                                <__A::Error as _serde::de::Error>::missing_field(
1074                                    "bInvertActive1",
1075                                ),
1076                            );
1077                            #[cfg(not(feature = "strict"))] Default::default()
1078                        }
1079                    };
1080                    let m_bIsActive2 = match m_bIsActive2 {
1081                        _serde::__private::Some(__field) => __field,
1082                        _serde::__private::None => {
1083                            #[cfg(feature = "strict")]
1084                            return _serde::__private::Err(
1085                                <__A::Error as _serde::de::Error>::missing_field(
1086                                    "bIsActive2",
1087                                ),
1088                            );
1089                            #[cfg(not(feature = "strict"))] Default::default()
1090                        }
1091                    };
1092                    let m_bInvertActive2 = match m_bInvertActive2 {
1093                        _serde::__private::Some(__field) => __field,
1094                        _serde::__private::None => {
1095                            #[cfg(feature = "strict")]
1096                            return _serde::__private::Err(
1097                                <__A::Error as _serde::de::Error>::missing_field(
1098                                    "bInvertActive2",
1099                                ),
1100                            );
1101                            #[cfg(not(feature = "strict"))] Default::default()
1102                        }
1103                    };
1104                    let m_bIsActive3 = match m_bIsActive3 {
1105                        _serde::__private::Some(__field) => __field,
1106                        _serde::__private::None => {
1107                            #[cfg(feature = "strict")]
1108                            return _serde::__private::Err(
1109                                <__A::Error as _serde::de::Error>::missing_field(
1110                                    "bIsActive3",
1111                                ),
1112                            );
1113                            #[cfg(not(feature = "strict"))] Default::default()
1114                        }
1115                    };
1116                    let m_bInvertActive3 = match m_bInvertActive3 {
1117                        _serde::__private::Some(__field) => __field,
1118                        _serde::__private::None => {
1119                            #[cfg(feature = "strict")]
1120                            return _serde::__private::Err(
1121                                <__A::Error as _serde::de::Error>::missing_field(
1122                                    "bInvertActive3",
1123                                ),
1124                            );
1125                            #[cfg(not(feature = "strict"))] Default::default()
1126                        }
1127                    };
1128                    let m_bIsActive4 = match m_bIsActive4 {
1129                        _serde::__private::Some(__field) => __field,
1130                        _serde::__private::None => {
1131                            #[cfg(feature = "strict")]
1132                            return _serde::__private::Err(
1133                                <__A::Error as _serde::de::Error>::missing_field(
1134                                    "bIsActive4",
1135                                ),
1136                            );
1137                            #[cfg(not(feature = "strict"))] Default::default()
1138                        }
1139                    };
1140                    let m_bInvertActive4 = match m_bInvertActive4 {
1141                        _serde::__private::Some(__field) => __field,
1142                        _serde::__private::None => {
1143                            #[cfg(feature = "strict")]
1144                            return _serde::__private::Err(
1145                                <__A::Error as _serde::de::Error>::missing_field(
1146                                    "bInvertActive4",
1147                                ),
1148                            );
1149                            #[cfg(not(feature = "strict"))] Default::default()
1150                        }
1151                    };
1152                    let __ptr = None;
1153                    let parent = hkBaseObject { __ptr };
1154                    let parent = hkReferencedObject {
1155                        __ptr,
1156                        parent,
1157                        ..Default::default()
1158                    };
1159                    let parent = hkbBindable {
1160                        __ptr,
1161                        parent,
1162                        m_variableBindingSet,
1163                        ..Default::default()
1164                    };
1165                    let parent = hkbNode {
1166                        __ptr,
1167                        parent,
1168                        m_userData,
1169                        m_name,
1170                        ..Default::default()
1171                    };
1172                    let parent = hkbModifier {
1173                        __ptr,
1174                        parent,
1175                        m_enable,
1176                        ..Default::default()
1177                    };
1178                    let __ptr = __A::class_ptr(&mut __map);
1179                    _serde::__private::Ok(BSIsActiveModifier {
1180                        __ptr,
1181                        parent,
1182                        m_bIsActive0,
1183                        m_bInvertActive0,
1184                        m_bIsActive1,
1185                        m_bInvertActive1,
1186                        m_bIsActive2,
1187                        m_bInvertActive2,
1188                        m_bIsActive3,
1189                        m_bInvertActive3,
1190                        m_bIsActive4,
1191                        m_bInvertActive4,
1192                    })
1193                }
1194            }
1195            const FIELDS: &[&str] = &[
1196                "bIsActive0",
1197                "bInvertActive0",
1198                "bIsActive1",
1199                "bInvertActive1",
1200                "bIsActive2",
1201                "bInvertActive2",
1202                "bIsActive3",
1203                "bInvertActive3",
1204                "bIsActive4",
1205                "bInvertActive4",
1206            ];
1207            _serde::Deserializer::deserialize_struct(
1208                deserializer,
1209                "BSIsActiveModifier",
1210                FIELDS,
1211                __BSIsActiveModifierVisitor {
1212                    marker: _serde::__private::PhantomData::<BSIsActiveModifier>,
1213                    lifetime: _serde::__private::PhantomData,
1214                },
1215            )
1216        }
1217    }
1218};