havok_classes/generated/
BSModifyOnceModifier_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `BSModifyOnceModifier`
5/// - version: `1`
6/// - signature: `0x1e20a97a`
7/// - size: ` 80`(x86)/`112`(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 BSModifyOnceModifier<'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: `pOnActivateModifier`(ctype: `struct hkbModifier*`)
33    /// - offset: ` 48`(x86)/` 80`(x86_64)
34    /// - type_size: `  4`(x86)/`  8`(x86_64)
35    /// - flags: `ALIGN_16`
36    #[cfg_attr(feature = "json_schema", schemars(rename = "pOnActivateModifier"))]
37    #[cfg_attr(feature = "serde", serde(rename = "pOnActivateModifier"))]
38    pub m_pOnActivateModifier: Pointer,
39    /// # C++ Info
40    /// - name: `pOnDeactivateModifier`(ctype: `struct hkbModifier*`)
41    /// - offset: ` 64`(x86)/` 96`(x86_64)
42    /// - type_size: `  4`(x86)/`  8`(x86_64)
43    /// - flags: `ALIGN_16`
44    #[cfg_attr(feature = "json_schema", schemars(rename = "pOnDeactivateModifier"))]
45    #[cfg_attr(feature = "serde", serde(rename = "pOnDeactivateModifier"))]
46    pub m_pOnDeactivateModifier: Pointer,
47}
48const _: () = {
49    use havok_serde as _serde;
50    impl<'a> _serde::HavokClass for BSModifyOnceModifier<'a> {
51        #[inline]
52        fn name(&self) -> &'static str {
53            "BSModifyOnceModifier"
54        }
55        #[inline]
56        fn signature(&self) -> _serde::__private::Signature {
57            _serde::__private::Signature::new(0x1e20a97a)
58        }
59        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
60        fn deps_indexes(&self) -> Vec<usize> {
61            let mut v = Vec::new();
62            v.push(self.parent.parent.parent.m_variableBindingSet.get());
63            v.push(self.m_pOnActivateModifier.get());
64            v.push(self.m_pOnDeactivateModifier.get());
65            v
66        }
67    }
68    impl<'a> _serde::Serialize for BSModifyOnceModifier<'a> {
69        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
70        where
71            S: _serde::ser::Serializer,
72        {
73            let class_meta = self
74                .__ptr
75                .map(|name| (name, _serde::__private::Signature::new(0x1e20a97a)));
76            let mut serializer = __serializer
77                .serialize_struct("BSModifyOnceModifier", class_meta, (80u64, 112u64))?;
78            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
79            serializer
80                .skip_field(
81                    "memSizeAndFlags",
82                    &self.parent.parent.parent.parent.m_memSizeAndFlags,
83                )?;
84            serializer
85                .skip_field(
86                    "referenceCount",
87                    &self.parent.parent.parent.parent.m_referenceCount,
88                )?;
89            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
90            serializer
91                .serialize_field(
92                    "variableBindingSet",
93                    &self.parent.parent.parent.m_variableBindingSet,
94                )?;
95            serializer
96                .skip_array_field(
97                    "cachedBindables",
98                    &self.parent.parent.parent.m_cachedBindables,
99                    TypeSize::NonPtr,
100                )?;
101            serializer
102                .skip_field(
103                    "areBindablesCached",
104                    &self.parent.parent.parent.m_areBindablesCached,
105                )?;
106            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
107            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
108            serializer.serialize_field("name", &self.parent.parent.m_name)?;
109            serializer.skip_field("id", &self.parent.parent.m_id)?;
110            serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
111            serializer
112                .skip_fixed_array_field(
113                    "padNode",
114                    self.parent.parent.m_padNode.as_slice(),
115                    TypeSize::NonPtr,
116                )?;
117            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
118            serializer.serialize_field("enable", &self.parent.m_enable)?;
119            serializer
120                .skip_fixed_array_field(
121                    "padModifier",
122                    self.parent.m_padModifier.as_slice(),
123                    TypeSize::NonPtr,
124                )?;
125            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
126            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
127            serializer
128                .serialize_field("pOnActivateModifier", &self.m_pOnActivateModifier)?;
129            serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 8usize].as_slice())?;
130            serializer
131                .serialize_field(
132                    "pOnDeactivateModifier",
133                    &self.m_pOnDeactivateModifier,
134                )?;
135            serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 8usize].as_slice())?;
136            serializer.end()
137        }
138    }
139};
140#[doc(hidden)]
141#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
142const _: () = {
143    use havok_serde as _serde;
144    #[automatically_derived]
145    impl<'de> _serde::Deserialize<'de> for BSModifyOnceModifier<'de> {
146        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
147        where
148            __D: _serde::Deserializer<'de>,
149        {
150            #[allow(non_camel_case_types)]
151            enum __Field {
152                m_variableBindingSet,
153                m_userData,
154                m_name,
155                m_enable,
156                m_pOnActivateModifier,
157                m_pOnDeactivateModifier,
158                __ignore,
159            }
160            struct __FieldVisitor;
161            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
162                type Value = __Field;
163                fn expecting(
164                    &self,
165                    __formatter: &mut core::fmt::Formatter,
166                ) -> core::fmt::Result {
167                    core::fmt::Formatter::write_str(__formatter, "field identifier")
168                }
169                /// Intended for use in XML.
170                #[allow(clippy::match_single_binding)]
171                #[allow(clippy::reversed_empty_ranges)]
172                #[allow(clippy::single_match)]
173                fn visit_key<__E>(
174                    self,
175                    __value: &str,
176                ) -> core::result::Result<Self::Value, __E>
177                where
178                    __E: _serde::de::Error,
179                {
180                    match __value {
181                        "variableBindingSet" => Ok(__Field::m_variableBindingSet),
182                        "userData" => Ok(__Field::m_userData),
183                        "name" => Ok(__Field::m_name),
184                        "enable" => Ok(__Field::m_enable),
185                        "pOnActivateModifier" => Ok(__Field::m_pOnActivateModifier),
186                        "pOnDeactivateModifier" => Ok(__Field::m_pOnDeactivateModifier),
187                        _ => Ok(__Field::__ignore),
188                    }
189                }
190            }
191            impl<'de> _serde::Deserialize<'de> for __Field {
192                #[inline]
193                fn deserialize<__D>(
194                    __deserializer: __D,
195                ) -> core::result::Result<Self, __D::Error>
196                where
197                    __D: _serde::Deserializer<'de>,
198                {
199                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
200                }
201            }
202            struct __BSModifyOnceModifierVisitor<'de> {
203                marker: _serde::__private::PhantomData<BSModifyOnceModifier<'de>>,
204                lifetime: _serde::__private::PhantomData<&'de ()>,
205            }
206            #[allow(clippy::match_single_binding)]
207            #[allow(clippy::reversed_empty_ranges)]
208            #[allow(clippy::single_match)]
209            impl<'de> _serde::de::Visitor<'de> for __BSModifyOnceModifierVisitor<'de> {
210                type Value = BSModifyOnceModifier<'de>;
211                fn expecting(
212                    &self,
213                    __formatter: &mut core::fmt::Formatter,
214                ) -> core::fmt::Result {
215                    core::fmt::Formatter::write_str(
216                        __formatter,
217                        "struct BSModifyOnceModifier",
218                    )
219                }
220                fn visit_struct_for_bytes<__A>(
221                    self,
222                    mut __map: __A,
223                ) -> _serde::__private::Result<Self::Value, __A::Error>
224                where
225                    __A: _serde::de::MapAccess<'de>,
226                {
227                    let __ptr = __A::class_ptr(&mut __map);
228                    let parent = __A::parent_value(&mut __map)?;
229                    let mut m_pOnActivateModifier: _serde::__private::Option<Pointer> = _serde::__private::None;
230                    let mut m_pOnDeactivateModifier: _serde::__private::Option<
231                        Pointer,
232                    > = _serde::__private::None;
233                    for i in 0..2usize {
234                        match i {
235                            0usize => {
236                                if _serde::__private::Option::is_some(
237                                    &m_pOnActivateModifier,
238                                ) {
239                                    return _serde::__private::Err(
240                                        <__A::Error as _serde::de::Error>::duplicate_field(
241                                            "pOnActivateModifier",
242                                        ),
243                                    );
244                                }
245                                __A::pad(&mut __map, 4usize, 0usize)?;
246                                m_pOnActivateModifier = _serde::__private::Some(
247                                    match __A::next_value::<Pointer>(&mut __map) {
248                                        _serde::__private::Ok(__val) => __val,
249                                        _serde::__private::Err(__err) => {
250                                            return _serde::__private::Err(__err);
251                                        }
252                                    },
253                                );
254                            }
255                            1usize => {
256                                if _serde::__private::Option::is_some(
257                                    &m_pOnDeactivateModifier,
258                                ) {
259                                    return _serde::__private::Err(
260                                        <__A::Error as _serde::de::Error>::duplicate_field(
261                                            "pOnDeactivateModifier",
262                                        ),
263                                    );
264                                }
265                                __A::pad(&mut __map, 12usize, 8usize)?;
266                                m_pOnDeactivateModifier = _serde::__private::Some(
267                                    match __A::next_value::<Pointer>(&mut __map) {
268                                        _serde::__private::Ok(__val) => __val,
269                                        _serde::__private::Err(__err) => {
270                                            return _serde::__private::Err(__err);
271                                        }
272                                    },
273                                );
274                            }
275                            _ => {}
276                        }
277                    }
278                    __A::pad(&mut __map, 12usize, 8usize)?;
279                    let m_pOnActivateModifier = match m_pOnActivateModifier {
280                        _serde::__private::Some(__field) => __field,
281                        _serde::__private::None => {
282                            return _serde::__private::Err(
283                                <__A::Error as _serde::de::Error>::missing_field(
284                                    "pOnActivateModifier",
285                                ),
286                            );
287                        }
288                    };
289                    let m_pOnDeactivateModifier = match m_pOnDeactivateModifier {
290                        _serde::__private::Some(__field) => __field,
291                        _serde::__private::None => {
292                            return _serde::__private::Err(
293                                <__A::Error as _serde::de::Error>::missing_field(
294                                    "pOnDeactivateModifier",
295                                ),
296                            );
297                        }
298                    };
299                    _serde::__private::Ok(BSModifyOnceModifier {
300                        __ptr,
301                        parent,
302                        m_pOnActivateModifier,
303                        m_pOnDeactivateModifier,
304                    })
305                }
306                #[allow(clippy::manual_unwrap_or_default)]
307                fn visit_struct<__A>(
308                    self,
309                    mut __map: __A,
310                ) -> _serde::__private::Result<Self::Value, __A::Error>
311                where
312                    __A: _serde::de::MapAccess<'de>,
313                {
314                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
315                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
316                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
317                    let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
318                    let mut m_pOnActivateModifier: _serde::__private::Option<Pointer> = _serde::__private::None;
319                    let mut m_pOnDeactivateModifier: _serde::__private::Option<
320                        Pointer,
321                    > = _serde::__private::None;
322                    while let _serde::__private::Some(__key) = {
323                        __A::next_key::<__Field>(&mut __map)?
324                    } {
325                        match __key {
326                            __Field::m_variableBindingSet => {
327                                #[cfg(
328                                    any(feature = "strict", feature = "ignore_duplicates")
329                                )]
330                                if _serde::__private::Option::is_some(
331                                    &m_variableBindingSet,
332                                ) {
333                                    #[cfg(feature = "ignore_duplicates")]
334                                    {
335                                        __A::skip_value(&mut __map)?;
336                                        continue;
337                                    }
338                                    #[cfg(feature = "strict")]
339                                    return _serde::__private::Err(
340                                        <__A::Error as _serde::de::Error>::duplicate_field(
341                                            "variableBindingSet",
342                                        ),
343                                    );
344                                }
345                                m_variableBindingSet = _serde::__private::Some(
346                                    match __A::next_value::<Pointer>(&mut __map) {
347                                        _serde::__private::Ok(__val) => __val,
348                                        _serde::__private::Err(__err) => {
349                                            return _serde::__private::Err(__err);
350                                        }
351                                    },
352                                );
353                            }
354                            __Field::m_userData => {
355                                #[cfg(
356                                    any(feature = "strict", feature = "ignore_duplicates")
357                                )]
358                                if _serde::__private::Option::is_some(&m_userData) {
359                                    #[cfg(feature = "ignore_duplicates")]
360                                    {
361                                        __A::skip_value(&mut __map)?;
362                                        continue;
363                                    }
364                                    #[cfg(feature = "strict")]
365                                    return _serde::__private::Err(
366                                        <__A::Error as _serde::de::Error>::duplicate_field(
367                                            "userData",
368                                        ),
369                                    );
370                                }
371                                m_userData = _serde::__private::Some(
372                                    match __A::next_value::<Ulong>(&mut __map) {
373                                        _serde::__private::Ok(__val) => __val,
374                                        _serde::__private::Err(__err) => {
375                                            return _serde::__private::Err(__err);
376                                        }
377                                    },
378                                );
379                            }
380                            __Field::m_name => {
381                                #[cfg(
382                                    any(feature = "strict", feature = "ignore_duplicates")
383                                )]
384                                if _serde::__private::Option::is_some(&m_name) {
385                                    #[cfg(feature = "ignore_duplicates")]
386                                    {
387                                        __A::skip_value(&mut __map)?;
388                                        continue;
389                                    }
390                                    #[cfg(feature = "strict")]
391                                    return _serde::__private::Err(
392                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
393                                    );
394                                }
395                                m_name = _serde::__private::Some(
396                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
397                                        _serde::__private::Ok(__val) => __val,
398                                        _serde::__private::Err(__err) => {
399                                            return _serde::__private::Err(__err);
400                                        }
401                                    },
402                                );
403                            }
404                            __Field::m_enable => {
405                                #[cfg(
406                                    any(feature = "strict", feature = "ignore_duplicates")
407                                )]
408                                if _serde::__private::Option::is_some(&m_enable) {
409                                    #[cfg(feature = "ignore_duplicates")]
410                                    {
411                                        __A::skip_value(&mut __map)?;
412                                        continue;
413                                    }
414                                    #[cfg(feature = "strict")]
415                                    return _serde::__private::Err(
416                                        <__A::Error as _serde::de::Error>::duplicate_field("enable"),
417                                    );
418                                }
419                                m_enable = _serde::__private::Some(
420                                    match __A::next_value::<bool>(&mut __map) {
421                                        _serde::__private::Ok(__val) => __val,
422                                        _serde::__private::Err(__err) => {
423                                            return _serde::__private::Err(__err);
424                                        }
425                                    },
426                                );
427                            }
428                            __Field::m_pOnActivateModifier => {
429                                #[cfg(
430                                    any(feature = "strict", feature = "ignore_duplicates")
431                                )]
432                                if _serde::__private::Option::is_some(
433                                    &m_pOnActivateModifier,
434                                ) {
435                                    #[cfg(feature = "ignore_duplicates")]
436                                    {
437                                        __A::skip_value(&mut __map)?;
438                                        continue;
439                                    }
440                                    #[cfg(feature = "strict")]
441                                    return _serde::__private::Err(
442                                        <__A::Error as _serde::de::Error>::duplicate_field(
443                                            "pOnActivateModifier",
444                                        ),
445                                    );
446                                }
447                                m_pOnActivateModifier = _serde::__private::Some(
448                                    match __A::next_value::<Pointer>(&mut __map) {
449                                        _serde::__private::Ok(__val) => __val,
450                                        _serde::__private::Err(__err) => {
451                                            return _serde::__private::Err(__err);
452                                        }
453                                    },
454                                );
455                            }
456                            __Field::m_pOnDeactivateModifier => {
457                                #[cfg(
458                                    any(feature = "strict", feature = "ignore_duplicates")
459                                )]
460                                if _serde::__private::Option::is_some(
461                                    &m_pOnDeactivateModifier,
462                                ) {
463                                    #[cfg(feature = "ignore_duplicates")]
464                                    {
465                                        __A::skip_value(&mut __map)?;
466                                        continue;
467                                    }
468                                    #[cfg(feature = "strict")]
469                                    return _serde::__private::Err(
470                                        <__A::Error as _serde::de::Error>::duplicate_field(
471                                            "pOnDeactivateModifier",
472                                        ),
473                                    );
474                                }
475                                m_pOnDeactivateModifier = _serde::__private::Some(
476                                    match __A::next_value::<Pointer>(&mut __map) {
477                                        _serde::__private::Ok(__val) => __val,
478                                        _serde::__private::Err(__err) => {
479                                            return _serde::__private::Err(__err);
480                                        }
481                                    },
482                                );
483                            }
484                            _ => __A::skip_value(&mut __map)?,
485                        }
486                    }
487                    let m_variableBindingSet = match m_variableBindingSet {
488                        _serde::__private::Some(__field) => __field,
489                        _serde::__private::None => {
490                            #[cfg(feature = "strict")]
491                            return _serde::__private::Err(
492                                <__A::Error as _serde::de::Error>::missing_field(
493                                    "variableBindingSet",
494                                ),
495                            );
496                            #[cfg(not(feature = "strict"))] Default::default()
497                        }
498                    };
499                    let m_userData = match m_userData {
500                        _serde::__private::Some(__field) => __field,
501                        _serde::__private::None => {
502                            #[cfg(feature = "strict")]
503                            return _serde::__private::Err(
504                                <__A::Error as _serde::de::Error>::missing_field("userData"),
505                            );
506                            #[cfg(not(feature = "strict"))] Default::default()
507                        }
508                    };
509                    let m_name = match m_name {
510                        _serde::__private::Some(__field) => __field,
511                        _serde::__private::None => {
512                            #[cfg(feature = "strict")]
513                            return _serde::__private::Err(
514                                <__A::Error as _serde::de::Error>::missing_field("name"),
515                            );
516                            #[cfg(not(feature = "strict"))] Default::default()
517                        }
518                    };
519                    let m_enable = match m_enable {
520                        _serde::__private::Some(__field) => __field,
521                        _serde::__private::None => {
522                            #[cfg(feature = "strict")]
523                            return _serde::__private::Err(
524                                <__A::Error as _serde::de::Error>::missing_field("enable"),
525                            );
526                            #[cfg(not(feature = "strict"))] Default::default()
527                        }
528                    };
529                    let m_pOnActivateModifier = match m_pOnActivateModifier {
530                        _serde::__private::Some(__field) => __field,
531                        _serde::__private::None => {
532                            #[cfg(feature = "strict")]
533                            return _serde::__private::Err(
534                                <__A::Error as _serde::de::Error>::missing_field(
535                                    "pOnActivateModifier",
536                                ),
537                            );
538                            #[cfg(not(feature = "strict"))] Default::default()
539                        }
540                    };
541                    let m_pOnDeactivateModifier = match m_pOnDeactivateModifier {
542                        _serde::__private::Some(__field) => __field,
543                        _serde::__private::None => {
544                            #[cfg(feature = "strict")]
545                            return _serde::__private::Err(
546                                <__A::Error as _serde::de::Error>::missing_field(
547                                    "pOnDeactivateModifier",
548                                ),
549                            );
550                            #[cfg(not(feature = "strict"))] Default::default()
551                        }
552                    };
553                    let __ptr = None;
554                    let parent = hkBaseObject { __ptr };
555                    let parent = hkReferencedObject {
556                        __ptr,
557                        parent,
558                        ..Default::default()
559                    };
560                    let parent = hkbBindable {
561                        __ptr,
562                        parent,
563                        m_variableBindingSet,
564                        ..Default::default()
565                    };
566                    let parent = hkbNode {
567                        __ptr,
568                        parent,
569                        m_userData,
570                        m_name,
571                        ..Default::default()
572                    };
573                    let parent = hkbModifier {
574                        __ptr,
575                        parent,
576                        m_enable,
577                        ..Default::default()
578                    };
579                    let __ptr = __A::class_ptr(&mut __map);
580                    _serde::__private::Ok(BSModifyOnceModifier {
581                        __ptr,
582                        parent,
583                        m_pOnActivateModifier,
584                        m_pOnDeactivateModifier,
585                    })
586                }
587            }
588            const FIELDS: &[&str] = &["pOnActivateModifier", "pOnDeactivateModifier"];
589            _serde::Deserializer::deserialize_struct(
590                deserializer,
591                "BSModifyOnceModifier",
592                FIELDS,
593                __BSModifyOnceModifierVisitor {
594                    marker: _serde::__private::PhantomData::<BSModifyOnceModifier>,
595                    lifetime: _serde::__private::PhantomData,
596                },
597            )
598        }
599    }
600};