havok_classes/generated/
hkbParticleSystemEventPayload_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbParticleSystemEventPayload`
5/// - version: `0`
6/// - signature: `0x9df46cd6`
7/// - size: ` 64`(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 hkbParticleSystemEventPayload {
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: hkbEventPayload,
30    /// # C++ Info
31    /// - name: `type`(ctype: `enum SystemType`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: `  1`(x86)/`  1`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "type"))]
35    #[cfg_attr(feature = "serde", serde(rename = "type"))]
36    pub m_type: SystemType,
37    /// # C++ Info
38    /// - name: `emitBoneIndex`(ctype: `hkInt16`)
39    /// - offset: ` 10`(x86)/` 18`(x86_64)
40    /// - type_size: `  2`(x86)/`  2`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "emitBoneIndex"))]
42    #[cfg_attr(feature = "serde", serde(rename = "emitBoneIndex"))]
43    pub m_emitBoneIndex: i16,
44    /// # C++ Info
45    /// - name: `offset`(ctype: `hkVector4`)
46    /// - offset: ` 16`(x86)/` 32`(x86_64)
47    /// - type_size: ` 16`(x86)/` 16`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "offset"))]
49    #[cfg_attr(feature = "serde", serde(rename = "offset"))]
50    pub m_offset: Vector4,
51    /// # C++ Info
52    /// - name: `direction`(ctype: `hkVector4`)
53    /// - offset: ` 32`(x86)/` 48`(x86_64)
54    /// - type_size: ` 16`(x86)/` 16`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "direction"))]
56    #[cfg_attr(feature = "serde", serde(rename = "direction"))]
57    pub m_direction: Vector4,
58    /// # C++ Info
59    /// - name: `numParticles`(ctype: `hkInt32`)
60    /// - offset: ` 48`(x86)/` 64`(x86_64)
61    /// - type_size: `  4`(x86)/`  4`(x86_64)
62    #[cfg_attr(feature = "json_schema", schemars(rename = "numParticles"))]
63    #[cfg_attr(feature = "serde", serde(rename = "numParticles"))]
64    pub m_numParticles: i32,
65    /// # C++ Info
66    /// - name: `speed`(ctype: `hkReal`)
67    /// - offset: ` 52`(x86)/` 68`(x86_64)
68    /// - type_size: `  4`(x86)/`  4`(x86_64)
69    #[cfg_attr(feature = "json_schema", schemars(rename = "speed"))]
70    #[cfg_attr(feature = "serde", serde(rename = "speed"))]
71    pub m_speed: f32,
72}
73const _: () = {
74    use havok_serde as _serde;
75    impl _serde::HavokClass for hkbParticleSystemEventPayload {
76        #[inline]
77        fn name(&self) -> &'static str {
78            "hkbParticleSystemEventPayload"
79        }
80        #[inline]
81        fn signature(&self) -> _serde::__private::Signature {
82            _serde::__private::Signature::new(0x9df46cd6)
83        }
84        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
85        fn deps_indexes(&self) -> Vec<usize> {
86            let mut v = Vec::new();
87            v
88        }
89    }
90    impl _serde::Serialize for hkbParticleSystemEventPayload {
91        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
92        where
93            S: _serde::ser::Serializer,
94        {
95            let class_meta = self
96                .__ptr
97                .map(|name| (name, _serde::__private::Signature::new(0x9df46cd6)));
98            let mut serializer = __serializer
99                .serialize_struct(
100                    "hkbParticleSystemEventPayload",
101                    class_meta,
102                    (64u64, 80u64),
103                )?;
104            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
105            serializer
106                .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
107            serializer
108                .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
109            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
110            serializer.serialize_field("type", &self.m_type)?;
111            serializer.pad_field([0u8; 1usize].as_slice(), [0u8; 1usize].as_slice())?;
112            serializer.serialize_field("emitBoneIndex", &self.m_emitBoneIndex)?;
113            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 12usize].as_slice())?;
114            serializer.serialize_field("offset", &self.m_offset)?;
115            serializer.serialize_field("direction", &self.m_direction)?;
116            serializer.serialize_field("numParticles", &self.m_numParticles)?;
117            serializer.serialize_field("speed", &self.m_speed)?;
118            serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 8usize].as_slice())?;
119            serializer.end()
120        }
121    }
122};
123#[doc(hidden)]
124#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
125const _: () = {
126    use havok_serde as _serde;
127    #[automatically_derived]
128    impl<'de> _serde::Deserialize<'de> for hkbParticleSystemEventPayload {
129        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
130        where
131            __D: _serde::Deserializer<'de>,
132        {
133            #[allow(non_camel_case_types)]
134            enum __Field {
135                m_type,
136                m_emitBoneIndex,
137                m_offset,
138                m_direction,
139                m_numParticles,
140                m_speed,
141                __ignore,
142            }
143            struct __FieldVisitor;
144            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
145                type Value = __Field;
146                fn expecting(
147                    &self,
148                    __formatter: &mut core::fmt::Formatter,
149                ) -> core::fmt::Result {
150                    core::fmt::Formatter::write_str(__formatter, "field identifier")
151                }
152                /// Intended for use in XML.
153                #[allow(clippy::match_single_binding)]
154                #[allow(clippy::reversed_empty_ranges)]
155                #[allow(clippy::single_match)]
156                fn visit_key<__E>(
157                    self,
158                    __value: &str,
159                ) -> core::result::Result<Self::Value, __E>
160                where
161                    __E: _serde::de::Error,
162                {
163                    match __value {
164                        "type" => Ok(__Field::m_type),
165                        "emitBoneIndex" => Ok(__Field::m_emitBoneIndex),
166                        "offset" => Ok(__Field::m_offset),
167                        "direction" => Ok(__Field::m_direction),
168                        "numParticles" => Ok(__Field::m_numParticles),
169                        "speed" => Ok(__Field::m_speed),
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 __hkbParticleSystemEventPayloadVisitor<'de> {
186                marker: _serde::__private::PhantomData<hkbParticleSystemEventPayload>,
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 __hkbParticleSystemEventPayloadVisitor<'de> {
194                type Value = hkbParticleSystemEventPayload;
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 hkbParticleSystemEventPayload",
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_type: _serde::__private::Option<SystemType> = _serde::__private::None;
214                    let mut m_emitBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
215                    let mut m_offset: _serde::__private::Option<Vector4> = _serde::__private::None;
216                    let mut m_direction: _serde::__private::Option<Vector4> = _serde::__private::None;
217                    let mut m_numParticles: _serde::__private::Option<i32> = _serde::__private::None;
218                    let mut m_speed: _serde::__private::Option<f32> = _serde::__private::None;
219                    for i in 0..6usize {
220                        match i {
221                            0usize => {
222                                if _serde::__private::Option::is_some(&m_type) {
223                                    return _serde::__private::Err(
224                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
225                                    );
226                                }
227                                m_type = _serde::__private::Some(
228                                    match __A::next_value::<SystemType>(&mut __map) {
229                                        _serde::__private::Ok(__val) => __val,
230                                        _serde::__private::Err(__err) => {
231                                            return _serde::__private::Err(__err);
232                                        }
233                                    },
234                                );
235                            }
236                            1usize => {
237                                if _serde::__private::Option::is_some(&m_emitBoneIndex) {
238                                    return _serde::__private::Err(
239                                        <__A::Error as _serde::de::Error>::duplicate_field(
240                                            "emitBoneIndex",
241                                        ),
242                                    );
243                                }
244                                __A::pad(&mut __map, 1usize, 1usize)?;
245                                m_emitBoneIndex = _serde::__private::Some(
246                                    match __A::next_value::<i16>(&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_offset) {
256                                    return _serde::__private::Err(
257                                        <__A::Error as _serde::de::Error>::duplicate_field("offset"),
258                                    );
259                                }
260                                __A::pad(&mut __map, 4usize, 12usize)?;
261                                m_offset = _serde::__private::Some(
262                                    match __A::next_value::<Vector4>(&mut __map) {
263                                        _serde::__private::Ok(__val) => __val,
264                                        _serde::__private::Err(__err) => {
265                                            return _serde::__private::Err(__err);
266                                        }
267                                    },
268                                );
269                            }
270                            3usize => {
271                                if _serde::__private::Option::is_some(&m_direction) {
272                                    return _serde::__private::Err(
273                                        <__A::Error as _serde::de::Error>::duplicate_field(
274                                            "direction",
275                                        ),
276                                    );
277                                }
278                                m_direction = _serde::__private::Some(
279                                    match __A::next_value::<Vector4>(&mut __map) {
280                                        _serde::__private::Ok(__val) => __val,
281                                        _serde::__private::Err(__err) => {
282                                            return _serde::__private::Err(__err);
283                                        }
284                                    },
285                                );
286                            }
287                            4usize => {
288                                if _serde::__private::Option::is_some(&m_numParticles) {
289                                    return _serde::__private::Err(
290                                        <__A::Error as _serde::de::Error>::duplicate_field(
291                                            "numParticles",
292                                        ),
293                                    );
294                                }
295                                m_numParticles = _serde::__private::Some(
296                                    match __A::next_value::<i32>(&mut __map) {
297                                        _serde::__private::Ok(__val) => __val,
298                                        _serde::__private::Err(__err) => {
299                                            return _serde::__private::Err(__err);
300                                        }
301                                    },
302                                );
303                            }
304                            5usize => {
305                                if _serde::__private::Option::is_some(&m_speed) {
306                                    return _serde::__private::Err(
307                                        <__A::Error as _serde::de::Error>::duplicate_field("speed"),
308                                    );
309                                }
310                                m_speed = _serde::__private::Some(
311                                    match __A::next_value::<f32>(&mut __map) {
312                                        _serde::__private::Ok(__val) => __val,
313                                        _serde::__private::Err(__err) => {
314                                            return _serde::__private::Err(__err);
315                                        }
316                                    },
317                                );
318                            }
319                            _ => {}
320                        }
321                    }
322                    __A::pad(&mut __map, 8usize, 8usize)?;
323                    let m_type = match m_type {
324                        _serde::__private::Some(__field) => __field,
325                        _serde::__private::None => {
326                            return _serde::__private::Err(
327                                <__A::Error as _serde::de::Error>::missing_field("type"),
328                            );
329                        }
330                    };
331                    let m_emitBoneIndex = match m_emitBoneIndex {
332                        _serde::__private::Some(__field) => __field,
333                        _serde::__private::None => {
334                            return _serde::__private::Err(
335                                <__A::Error as _serde::de::Error>::missing_field(
336                                    "emitBoneIndex",
337                                ),
338                            );
339                        }
340                    };
341                    let m_offset = match m_offset {
342                        _serde::__private::Some(__field) => __field,
343                        _serde::__private::None => {
344                            return _serde::__private::Err(
345                                <__A::Error as _serde::de::Error>::missing_field("offset"),
346                            );
347                        }
348                    };
349                    let m_direction = match m_direction {
350                        _serde::__private::Some(__field) => __field,
351                        _serde::__private::None => {
352                            return _serde::__private::Err(
353                                <__A::Error as _serde::de::Error>::missing_field(
354                                    "direction",
355                                ),
356                            );
357                        }
358                    };
359                    let m_numParticles = match m_numParticles {
360                        _serde::__private::Some(__field) => __field,
361                        _serde::__private::None => {
362                            return _serde::__private::Err(
363                                <__A::Error as _serde::de::Error>::missing_field(
364                                    "numParticles",
365                                ),
366                            );
367                        }
368                    };
369                    let m_speed = match m_speed {
370                        _serde::__private::Some(__field) => __field,
371                        _serde::__private::None => {
372                            return _serde::__private::Err(
373                                <__A::Error as _serde::de::Error>::missing_field("speed"),
374                            );
375                        }
376                    };
377                    _serde::__private::Ok(hkbParticleSystemEventPayload {
378                        __ptr,
379                        parent,
380                        m_type,
381                        m_emitBoneIndex,
382                        m_offset,
383                        m_direction,
384                        m_numParticles,
385                        m_speed,
386                    })
387                }
388                #[allow(clippy::manual_unwrap_or_default)]
389                fn visit_struct<__A>(
390                    self,
391                    mut __map: __A,
392                ) -> _serde::__private::Result<Self::Value, __A::Error>
393                where
394                    __A: _serde::de::MapAccess<'de>,
395                {
396                    let mut m_type: _serde::__private::Option<SystemType> = _serde::__private::None;
397                    let mut m_emitBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
398                    let mut m_offset: _serde::__private::Option<Vector4> = _serde::__private::None;
399                    let mut m_direction: _serde::__private::Option<Vector4> = _serde::__private::None;
400                    let mut m_numParticles: _serde::__private::Option<i32> = _serde::__private::None;
401                    let mut m_speed: _serde::__private::Option<f32> = _serde::__private::None;
402                    while let _serde::__private::Some(__key) = {
403                        __A::next_key::<__Field>(&mut __map)?
404                    } {
405                        match __key {
406                            __Field::m_type => {
407                                #[cfg(
408                                    any(feature = "strict", feature = "ignore_duplicates")
409                                )]
410                                if _serde::__private::Option::is_some(&m_type) {
411                                    #[cfg(feature = "ignore_duplicates")]
412                                    {
413                                        __A::skip_value(&mut __map)?;
414                                        continue;
415                                    }
416                                    #[cfg(feature = "strict")]
417                                    return _serde::__private::Err(
418                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
419                                    );
420                                }
421                                m_type = _serde::__private::Some(
422                                    match __A::next_value::<SystemType>(&mut __map) {
423                                        _serde::__private::Ok(__val) => __val,
424                                        _serde::__private::Err(__err) => {
425                                            return _serde::__private::Err(__err);
426                                        }
427                                    },
428                                );
429                            }
430                            __Field::m_emitBoneIndex => {
431                                #[cfg(
432                                    any(feature = "strict", feature = "ignore_duplicates")
433                                )]
434                                if _serde::__private::Option::is_some(&m_emitBoneIndex) {
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                                            "emitBoneIndex",
444                                        ),
445                                    );
446                                }
447                                m_emitBoneIndex = _serde::__private::Some(
448                                    match __A::next_value::<i16>(&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_offset => {
457                                #[cfg(
458                                    any(feature = "strict", feature = "ignore_duplicates")
459                                )]
460                                if _serde::__private::Option::is_some(&m_offset) {
461                                    #[cfg(feature = "ignore_duplicates")]
462                                    {
463                                        __A::skip_value(&mut __map)?;
464                                        continue;
465                                    }
466                                    #[cfg(feature = "strict")]
467                                    return _serde::__private::Err(
468                                        <__A::Error as _serde::de::Error>::duplicate_field("offset"),
469                                    );
470                                }
471                                m_offset = _serde::__private::Some(
472                                    match __A::next_value::<Vector4>(&mut __map) {
473                                        _serde::__private::Ok(__val) => __val,
474                                        _serde::__private::Err(__err) => {
475                                            return _serde::__private::Err(__err);
476                                        }
477                                    },
478                                );
479                            }
480                            __Field::m_direction => {
481                                #[cfg(
482                                    any(feature = "strict", feature = "ignore_duplicates")
483                                )]
484                                if _serde::__private::Option::is_some(&m_direction) {
485                                    #[cfg(feature = "ignore_duplicates")]
486                                    {
487                                        __A::skip_value(&mut __map)?;
488                                        continue;
489                                    }
490                                    #[cfg(feature = "strict")]
491                                    return _serde::__private::Err(
492                                        <__A::Error as _serde::de::Error>::duplicate_field(
493                                            "direction",
494                                        ),
495                                    );
496                                }
497                                m_direction = _serde::__private::Some(
498                                    match __A::next_value::<Vector4>(&mut __map) {
499                                        _serde::__private::Ok(__val) => __val,
500                                        _serde::__private::Err(__err) => {
501                                            return _serde::__private::Err(__err);
502                                        }
503                                    },
504                                );
505                            }
506                            __Field::m_numParticles => {
507                                #[cfg(
508                                    any(feature = "strict", feature = "ignore_duplicates")
509                                )]
510                                if _serde::__private::Option::is_some(&m_numParticles) {
511                                    #[cfg(feature = "ignore_duplicates")]
512                                    {
513                                        __A::skip_value(&mut __map)?;
514                                        continue;
515                                    }
516                                    #[cfg(feature = "strict")]
517                                    return _serde::__private::Err(
518                                        <__A::Error as _serde::de::Error>::duplicate_field(
519                                            "numParticles",
520                                        ),
521                                    );
522                                }
523                                m_numParticles = _serde::__private::Some(
524                                    match __A::next_value::<i32>(&mut __map) {
525                                        _serde::__private::Ok(__val) => __val,
526                                        _serde::__private::Err(__err) => {
527                                            return _serde::__private::Err(__err);
528                                        }
529                                    },
530                                );
531                            }
532                            __Field::m_speed => {
533                                #[cfg(
534                                    any(feature = "strict", feature = "ignore_duplicates")
535                                )]
536                                if _serde::__private::Option::is_some(&m_speed) {
537                                    #[cfg(feature = "ignore_duplicates")]
538                                    {
539                                        __A::skip_value(&mut __map)?;
540                                        continue;
541                                    }
542                                    #[cfg(feature = "strict")]
543                                    return _serde::__private::Err(
544                                        <__A::Error as _serde::de::Error>::duplicate_field("speed"),
545                                    );
546                                }
547                                m_speed = _serde::__private::Some(
548                                    match __A::next_value::<f32>(&mut __map) {
549                                        _serde::__private::Ok(__val) => __val,
550                                        _serde::__private::Err(__err) => {
551                                            return _serde::__private::Err(__err);
552                                        }
553                                    },
554                                );
555                            }
556                            _ => __A::skip_value(&mut __map)?,
557                        }
558                    }
559                    let m_type = match m_type {
560                        _serde::__private::Some(__field) => __field,
561                        _serde::__private::None => {
562                            #[cfg(feature = "strict")]
563                            return _serde::__private::Err(
564                                <__A::Error as _serde::de::Error>::missing_field("type"),
565                            );
566                            #[cfg(not(feature = "strict"))] Default::default()
567                        }
568                    };
569                    let m_emitBoneIndex = match m_emitBoneIndex {
570                        _serde::__private::Some(__field) => __field,
571                        _serde::__private::None => {
572                            #[cfg(feature = "strict")]
573                            return _serde::__private::Err(
574                                <__A::Error as _serde::de::Error>::missing_field(
575                                    "emitBoneIndex",
576                                ),
577                            );
578                            #[cfg(not(feature = "strict"))] Default::default()
579                        }
580                    };
581                    let m_offset = match m_offset {
582                        _serde::__private::Some(__field) => __field,
583                        _serde::__private::None => {
584                            #[cfg(feature = "strict")]
585                            return _serde::__private::Err(
586                                <__A::Error as _serde::de::Error>::missing_field("offset"),
587                            );
588                            #[cfg(not(feature = "strict"))] Default::default()
589                        }
590                    };
591                    let m_direction = match m_direction {
592                        _serde::__private::Some(__field) => __field,
593                        _serde::__private::None => {
594                            #[cfg(feature = "strict")]
595                            return _serde::__private::Err(
596                                <__A::Error as _serde::de::Error>::missing_field(
597                                    "direction",
598                                ),
599                            );
600                            #[cfg(not(feature = "strict"))] Default::default()
601                        }
602                    };
603                    let m_numParticles = match m_numParticles {
604                        _serde::__private::Some(__field) => __field,
605                        _serde::__private::None => {
606                            #[cfg(feature = "strict")]
607                            return _serde::__private::Err(
608                                <__A::Error as _serde::de::Error>::missing_field(
609                                    "numParticles",
610                                ),
611                            );
612                            #[cfg(not(feature = "strict"))] Default::default()
613                        }
614                    };
615                    let m_speed = match m_speed {
616                        _serde::__private::Some(__field) => __field,
617                        _serde::__private::None => {
618                            #[cfg(feature = "strict")]
619                            return _serde::__private::Err(
620                                <__A::Error as _serde::de::Error>::missing_field("speed"),
621                            );
622                            #[cfg(not(feature = "strict"))] Default::default()
623                        }
624                    };
625                    let __ptr = None;
626                    let parent = hkBaseObject { __ptr };
627                    let parent = hkReferencedObject {
628                        __ptr,
629                        parent,
630                        ..Default::default()
631                    };
632                    let parent = hkbEventPayload { __ptr, parent };
633                    let __ptr = __A::class_ptr(&mut __map);
634                    _serde::__private::Ok(hkbParticleSystemEventPayload {
635                        __ptr,
636                        parent,
637                        m_type,
638                        m_emitBoneIndex,
639                        m_offset,
640                        m_direction,
641                        m_numParticles,
642                        m_speed,
643                    })
644                }
645            }
646            const FIELDS: &[&str] = &[
647                "type",
648                "emitBoneIndex",
649                "offset",
650                "direction",
651                "numParticles",
652                "speed",
653            ];
654            _serde::Deserializer::deserialize_struct(
655                deserializer,
656                "hkbParticleSystemEventPayload",
657                FIELDS,
658                __hkbParticleSystemEventPayloadVisitor {
659                    marker: _serde::__private::PhantomData::<
660                        hkbParticleSystemEventPayload,
661                    >,
662                    lifetime: _serde::__private::PhantomData,
663                },
664            )
665        }
666    }
667};
668/// # C++ Info
669/// - name: `SystemType`(ctype: `hkEnum<SystemType, hkUint8>`)
670#[allow(non_upper_case_globals, non_snake_case)]
671#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
672#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
673#[derive(
674    Debug,
675    Clone,
676    Default,
677    PartialEq,
678    Eq,
679    PartialOrd,
680    Ord,
681    num_derive::ToPrimitive,
682    num_derive::FromPrimitive,
683)]
684pub enum SystemType {
685    #[default]
686    DEBRIS = 0isize,
687    DUST = 1isize,
688    EXPLOSION = 2isize,
689    SMOKE = 3isize,
690    SPARKS = 4isize,
691}
692const _: () = {
693    use havok_serde as __serde;
694    impl __serde::Serialize for SystemType {
695        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
696        where
697            S: __serde::ser::Serializer,
698        {
699            let mut __serializer = __serializer.serialize_enum_flags()?;
700            match self {
701                Self::DEBRIS => __serializer.serialize_field("DEBRIS", &0u64),
702                Self::DUST => __serializer.serialize_field("DUST", &1u64),
703                Self::EXPLOSION => __serializer.serialize_field("EXPLOSION", &2u64),
704                Self::SMOKE => __serializer.serialize_field("SMOKE", &3u64),
705                Self::SPARKS => __serializer.serialize_field("SPARKS", &4u64),
706            }?;
707            use num_traits::ToPrimitive as _;
708            let num = self
709                .to_u8()
710                .ok_or(S::Error::custom("Failed enum SystemType to_u8"))?;
711            __serializer.serialize_bits(&num)?;
712            __serializer.end()
713        }
714    }
715};
716#[doc(hidden)]
717#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
718const _: () = {
719    #[allow(unused_extern_crates, clippy::useless_attribute)]
720    extern crate havok_serde as _serde;
721    #[automatically_derived]
722    impl<'de> _serde::Deserialize<'de> for SystemType {
723        fn deserialize<__D>(
724            __deserializer: __D,
725        ) -> _serde::__private::Result<Self, __D::Error>
726        where
727            __D: _serde::Deserializer<'de>,
728        {
729            #[allow(non_camel_case_types)]
730            #[doc(hidden)]
731            enum __Field {
732                __field0,
733                __field1,
734                __field2,
735                __field3,
736                __field4,
737            }
738            #[doc(hidden)]
739            struct __FieldVisitor;
740            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
741                type Value = __Field;
742                fn expecting(
743                    &self,
744                    __formatter: &mut _serde::__private::Formatter,
745                ) -> _serde::__private::fmt::Result {
746                    _serde::__private::Formatter::write_str(
747                        __formatter,
748                        "variant identifier",
749                    )
750                }
751                fn visit_uint8<__E>(
752                    self,
753                    __value: u8,
754                ) -> _serde::__private::Result<Self::Value, __E>
755                where
756                    __E: _serde::de::Error,
757                {
758                    match __value {
759                        0u8 => _serde::__private::Ok(__Field::__field0),
760                        1u8 => _serde::__private::Ok(__Field::__field1),
761                        2u8 => _serde::__private::Ok(__Field::__field2),
762                        3u8 => _serde::__private::Ok(__Field::__field3),
763                        4u8 => _serde::__private::Ok(__Field::__field4),
764                        _ => {
765                            _serde::__private::Err(
766                                _serde::de::Error::invalid_value(
767                                    _serde::de::Unexpected::Uint8(__value),
768                                    &"value(u8) of variant is one of 0, 1, 2, 3, 4",
769                                ),
770                            )
771                        }
772                    }
773                }
774                fn visit_stringptr<__E>(
775                    self,
776                    __value: StringPtr<'de>,
777                ) -> _serde::__private::Result<Self::Value, __E>
778                where
779                    __E: _serde::de::Error,
780                {
781                    if let Some(__value) = __value.into_inner() {
782                        match __value.as_ref() {
783                            v if v == "0" || v.eq_ignore_ascii_case("DEBRIS") => {
784                                _serde::__private::Ok(__Field::__field0)
785                            }
786                            v if v == "1" || v.eq_ignore_ascii_case("DUST") => {
787                                _serde::__private::Ok(__Field::__field1)
788                            }
789                            v if v == "2" || v.eq_ignore_ascii_case("EXPLOSION") => {
790                                _serde::__private::Ok(__Field::__field2)
791                            }
792                            v if v == "3" || v.eq_ignore_ascii_case("SMOKE") => {
793                                _serde::__private::Ok(__Field::__field3)
794                            }
795                            v if v == "4" || v.eq_ignore_ascii_case("SPARKS") => {
796                                _serde::__private::Ok(__Field::__field4)
797                            }
798                            _ => {
799                                _serde::__private::Err(
800                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
801                                )
802                            }
803                        }
804                    } else {
805                        _serde::__private::Err(
806                            _serde::de::Error::unknown_variant("None", VARIANTS),
807                        )
808                    }
809                }
810            }
811            impl<'de> _serde::Deserialize<'de> for __Field {
812                #[inline]
813                fn deserialize<__D>(
814                    __deserializer: __D,
815                ) -> _serde::__private::Result<Self, __D::Error>
816                where
817                    __D: _serde::Deserializer<'de>,
818                {
819                    _serde::Deserializer::deserialize_identifier(
820                        __deserializer,
821                        _serde::de::ReadEnumSize::Uint8,
822                        __FieldVisitor,
823                    )
824                }
825            }
826            #[doc(hidden)]
827            struct __Visitor<'de> {
828                marker: _serde::__private::PhantomData<SystemType>,
829                lifetime: _serde::__private::PhantomData<&'de ()>,
830            }
831            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
832                type Value = SystemType;
833                fn expecting(
834                    &self,
835                    __formatter: &mut _serde::__private::Formatter,
836                ) -> _serde::__private::fmt::Result {
837                    _serde::__private::Formatter::write_str(
838                        __formatter,
839                        "enum SystemType",
840                    )
841                }
842                fn visit_enum<__A>(
843                    self,
844                    __data: __A,
845                ) -> _serde::__private::Result<Self::Value, __A::Error>
846                where
847                    __A: _serde::de::EnumAccess<'de>,
848                {
849                    match _serde::de::EnumAccess::variant(__data)? {
850                        (__Field::__field0, __variant) => {
851                            _serde::de::VariantAccess::unit_variant(__variant)?;
852                            _serde::__private::Ok(SystemType::DEBRIS)
853                        }
854                        (__Field::__field1, __variant) => {
855                            _serde::de::VariantAccess::unit_variant(__variant)?;
856                            _serde::__private::Ok(SystemType::DUST)
857                        }
858                        (__Field::__field2, __variant) => {
859                            _serde::de::VariantAccess::unit_variant(__variant)?;
860                            _serde::__private::Ok(SystemType::EXPLOSION)
861                        }
862                        (__Field::__field3, __variant) => {
863                            _serde::de::VariantAccess::unit_variant(__variant)?;
864                            _serde::__private::Ok(SystemType::SMOKE)
865                        }
866                        (__Field::__field4, __variant) => {
867                            _serde::de::VariantAccess::unit_variant(__variant)?;
868                            _serde::__private::Ok(SystemType::SPARKS)
869                        }
870                    }
871                }
872            }
873            #[doc(hidden)]
874            const VARIANTS: &'static [&'static str] = &[
875                "DEBRIS",
876                "DUST",
877                "EXPLOSION",
878                "SMOKE",
879                "SPARKS",
880            ];
881            _serde::Deserializer::deserialize_enum(
882                __deserializer,
883                "SystemType",
884                VARIANTS,
885                __Visitor {
886                    marker: _serde::__private::PhantomData::<SystemType>,
887                    lifetime: _serde::__private::PhantomData,
888                },
889            )
890        }
891    }
892};
havok_classes/generated/hkbParticleSystemEventPayload_.rs

havok_classes/generated/
hkbParticleSystemEventPayload_.rs
