havok_classes/generated/
hkpLinearParametricCurve_.rs

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

havok_classes/generated/
hkpLinearParametricCurve_.rs
