havok_classes/generated/
hkbBlenderGeneratorChild_.rs

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

havok_classes/generated/
hkbBlenderGeneratorChild_.rs
