havok_classes/generated/
hkbEvaluateExpressionModifier_.rs

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

havok_classes/generated/
hkbEvaluateExpressionModifier_.rs
