havok_classes/generated/
BSInterpValueModifier_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `BSInterpValueModifier`
5/// - version: `0`
6/// - signature: `0x29adc802`
7/// - size: ` 64`(x86)/`104`(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 BSInterpValueModifier<'a> {
15    /// # Unique index for this class
16    /// - Represents a pointer on XML (`<hkobject name="#0001"></hkobject>`)
17    /// - [`Option::None`] => This class is `class in field`.(`<hkobject></hkobject>`)
18    ///
19    /// # Note
20    /// Not present in the binary & Not exist actual C++ field.
21    #[cfg_attr(
22        feature = "serde",
23        serde(skip_serializing_if = "Option::is_none", default)
24    )]
25    pub __ptr: Option<Pointer>,
26    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    #[cfg_attr(feature = "serde", serde(borrow))]
30    pub parent: hkbModifier<'a>,
31    /// # C++ Info
32    /// - name: `source`(ctype: `hkReal`)
33    /// - offset: ` 44`(x86)/` 80`(x86_64)
34    /// - type_size: `  4`(x86)/`  4`(x86_64)
35    #[cfg_attr(feature = "json_schema", schemars(rename = "source"))]
36    #[cfg_attr(feature = "serde", serde(rename = "source"))]
37    pub m_source: f32,
38    /// # C++ Info
39    /// - name: `target`(ctype: `hkReal`)
40    /// - offset: ` 48`(x86)/` 84`(x86_64)
41    /// - type_size: `  4`(x86)/`  4`(x86_64)
42    #[cfg_attr(feature = "json_schema", schemars(rename = "target"))]
43    #[cfg_attr(feature = "serde", serde(rename = "target"))]
44    pub m_target: f32,
45    /// # C++ Info
46    /// - name: `result`(ctype: `hkReal`)
47    /// - offset: ` 52`(x86)/` 88`(x86_64)
48    /// - type_size: `  4`(x86)/`  4`(x86_64)
49    #[cfg_attr(feature = "json_schema", schemars(rename = "result"))]
50    #[cfg_attr(feature = "serde", serde(rename = "result"))]
51    pub m_result: f32,
52    /// # C++ Info
53    /// - name: `gain`(ctype: `hkReal`)
54    /// - offset: ` 56`(x86)/` 92`(x86_64)
55    /// - type_size: `  4`(x86)/`  4`(x86_64)
56    #[cfg_attr(feature = "json_schema", schemars(rename = "gain"))]
57    #[cfg_attr(feature = "serde", serde(rename = "gain"))]
58    pub m_gain: f32,
59    /// # C++ Info
60    /// - name: `timeStep`(ctype: `hkReal`)
61    /// - offset: ` 60`(x86)/` 96`(x86_64)
62    /// - type_size: `  4`(x86)/`  4`(x86_64)
63    /// - flags: `SERIALIZE_IGNORED`
64    #[cfg_attr(feature = "json_schema", schemars(rename = "timeStep"))]
65    #[cfg_attr(feature = "serde", serde(rename = "timeStep"))]
66    pub m_timeStep: f32,
67}
68const _: () = {
69    use havok_serde as _serde;
70    impl<'a> _serde::HavokClass for BSInterpValueModifier<'a> {
71        #[inline]
72        fn name(&self) -> &'static str {
73            "BSInterpValueModifier"
74        }
75        #[inline]
76        fn signature(&self) -> _serde::__private::Signature {
77            _serde::__private::Signature::new(0x29adc802)
78        }
79        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
80        fn deps_indexes(&self) -> Vec<usize> {
81            let mut v = Vec::new();
82            v.push(self.parent.parent.parent.m_variableBindingSet.get());
83            v
84        }
85    }
86    impl<'a> _serde::Serialize for BSInterpValueModifier<'a> {
87        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
88        where
89            S: _serde::ser::Serializer,
90        {
91            let class_meta = self
92                .__ptr
93                .map(|name| (name, _serde::__private::Signature::new(0x29adc802)));
94            let mut serializer = __serializer
95                .serialize_struct("BSInterpValueModifier", class_meta, (64u64, 104u64))?;
96            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
97            serializer
98                .skip_field(
99                    "memSizeAndFlags",
100                    &self.parent.parent.parent.parent.m_memSizeAndFlags,
101                )?;
102            serializer
103                .skip_field(
104                    "referenceCount",
105                    &self.parent.parent.parent.parent.m_referenceCount,
106                )?;
107            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
108            serializer
109                .serialize_field(
110                    "variableBindingSet",
111                    &self.parent.parent.parent.m_variableBindingSet,
112                )?;
113            serializer
114                .skip_array_field(
115                    "cachedBindables",
116                    &self.parent.parent.parent.m_cachedBindables,
117                    TypeSize::NonPtr,
118                )?;
119            serializer
120                .skip_field(
121                    "areBindablesCached",
122                    &self.parent.parent.parent.m_areBindablesCached,
123                )?;
124            serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
125            serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
126            serializer.serialize_field("name", &self.parent.parent.m_name)?;
127            serializer.skip_field("id", &self.parent.parent.m_id)?;
128            serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
129            serializer
130                .skip_fixed_array_field(
131                    "padNode",
132                    self.parent.parent.m_padNode.as_slice(),
133                    TypeSize::NonPtr,
134                )?;
135            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
136            serializer.serialize_field("enable", &self.parent.m_enable)?;
137            serializer
138                .skip_fixed_array_field(
139                    "padModifier",
140                    self.parent.m_padModifier.as_slice(),
141                    TypeSize::NonPtr,
142                )?;
143            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
144            serializer.serialize_field("source", &self.m_source)?;
145            serializer.serialize_field("target", &self.m_target)?;
146            serializer.serialize_field("result", &self.m_result)?;
147            serializer.serialize_field("gain", &self.m_gain)?;
148            serializer.skip_field("timeStep", &self.m_timeStep)?;
149            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
150            serializer.end()
151        }
152    }
153};
154#[doc(hidden)]
155#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
156const _: () = {
157    use havok_serde as _serde;
158    #[automatically_derived]
159    impl<'de> _serde::Deserialize<'de> for BSInterpValueModifier<'de> {
160        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
161        where
162            __D: _serde::Deserializer<'de>,
163        {
164            #[allow(non_camel_case_types)]
165            enum __Field {
166                m_variableBindingSet,
167                m_userData,
168                m_name,
169                m_enable,
170                m_source,
171                m_target,
172                m_result,
173                m_gain,
174                __ignore,
175            }
176            struct __FieldVisitor;
177            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
178                type Value = __Field;
179                fn expecting(
180                    &self,
181                    __formatter: &mut core::fmt::Formatter,
182                ) -> core::fmt::Result {
183                    core::fmt::Formatter::write_str(__formatter, "field identifier")
184                }
185                /// Intended for use in XML.
186                #[allow(clippy::match_single_binding)]
187                #[allow(clippy::reversed_empty_ranges)]
188                #[allow(clippy::single_match)]
189                fn visit_key<__E>(
190                    self,
191                    __value: &str,
192                ) -> core::result::Result<Self::Value, __E>
193                where
194                    __E: _serde::de::Error,
195                {
196                    match __value {
197                        "variableBindingSet" => Ok(__Field::m_variableBindingSet),
198                        "userData" => Ok(__Field::m_userData),
199                        "name" => Ok(__Field::m_name),
200                        "enable" => Ok(__Field::m_enable),
201                        "source" => Ok(__Field::m_source),
202                        "target" => Ok(__Field::m_target),
203                        "result" => Ok(__Field::m_result),
204                        "gain" => Ok(__Field::m_gain),
205                        _ => Ok(__Field::__ignore),
206                    }
207                }
208            }
209            impl<'de> _serde::Deserialize<'de> for __Field {
210                #[inline]
211                fn deserialize<__D>(
212                    __deserializer: __D,
213                ) -> core::result::Result<Self, __D::Error>
214                where
215                    __D: _serde::Deserializer<'de>,
216                {
217                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
218                }
219            }
220            struct __BSInterpValueModifierVisitor<'de> {
221                marker: _serde::__private::PhantomData<BSInterpValueModifier<'de>>,
222                lifetime: _serde::__private::PhantomData<&'de ()>,
223            }
224            #[allow(clippy::match_single_binding)]
225            #[allow(clippy::reversed_empty_ranges)]
226            #[allow(clippy::single_match)]
227            impl<'de> _serde::de::Visitor<'de> for __BSInterpValueModifierVisitor<'de> {
228                type Value = BSInterpValueModifier<'de>;
229                fn expecting(
230                    &self,
231                    __formatter: &mut core::fmt::Formatter,
232                ) -> core::fmt::Result {
233                    core::fmt::Formatter::write_str(
234                        __formatter,
235                        "struct BSInterpValueModifier",
236                    )
237                }
238                fn visit_struct_for_bytes<__A>(
239                    self,
240                    mut __map: __A,
241                ) -> _serde::__private::Result<Self::Value, __A::Error>
242                where
243                    __A: _serde::de::MapAccess<'de>,
244                {
245                    let __ptr = __A::class_ptr(&mut __map);
246                    let parent = __A::parent_value(&mut __map)?;
247                    let mut m_source: _serde::__private::Option<f32> = _serde::__private::None;
248                    let mut m_target: _serde::__private::Option<f32> = _serde::__private::None;
249                    let mut m_result: _serde::__private::Option<f32> = _serde::__private::None;
250                    let mut m_gain: _serde::__private::Option<f32> = _serde::__private::None;
251                    let mut m_timeStep: _serde::__private::Option<f32> = _serde::__private::None;
252                    for i in 0..5usize {
253                        match i {
254                            0usize => {
255                                if _serde::__private::Option::is_some(&m_source) {
256                                    return _serde::__private::Err(
257                                        <__A::Error as _serde::de::Error>::duplicate_field("source"),
258                                    );
259                                }
260                                m_source = _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                            1usize => {
270                                if _serde::__private::Option::is_some(&m_target) {
271                                    return _serde::__private::Err(
272                                        <__A::Error as _serde::de::Error>::duplicate_field("target"),
273                                    );
274                                }
275                                m_target = _serde::__private::Some(
276                                    match __A::next_value::<f32>(&mut __map) {
277                                        _serde::__private::Ok(__val) => __val,
278                                        _serde::__private::Err(__err) => {
279                                            return _serde::__private::Err(__err);
280                                        }
281                                    },
282                                );
283                            }
284                            2usize => {
285                                if _serde::__private::Option::is_some(&m_result) {
286                                    return _serde::__private::Err(
287                                        <__A::Error as _serde::de::Error>::duplicate_field("result"),
288                                    );
289                                }
290                                m_result = _serde::__private::Some(
291                                    match __A::next_value::<f32>(&mut __map) {
292                                        _serde::__private::Ok(__val) => __val,
293                                        _serde::__private::Err(__err) => {
294                                            return _serde::__private::Err(__err);
295                                        }
296                                    },
297                                );
298                            }
299                            3usize => {
300                                if _serde::__private::Option::is_some(&m_gain) {
301                                    return _serde::__private::Err(
302                                        <__A::Error as _serde::de::Error>::duplicate_field("gain"),
303                                    );
304                                }
305                                m_gain = _serde::__private::Some(
306                                    match __A::next_value::<f32>(&mut __map) {
307                                        _serde::__private::Ok(__val) => __val,
308                                        _serde::__private::Err(__err) => {
309                                            return _serde::__private::Err(__err);
310                                        }
311                                    },
312                                );
313                            }
314                            4usize => {
315                                if _serde::__private::Option::is_some(&m_timeStep) {
316                                    return _serde::__private::Err(
317                                        <__A::Error as _serde::de::Error>::duplicate_field(
318                                            "timeStep",
319                                        ),
320                                    );
321                                }
322                                m_timeStep = _serde::__private::Some(
323                                    match __A::next_value::<f32>(&mut __map) {
324                                        _serde::__private::Ok(__val) => __val,
325                                        _serde::__private::Err(__err) => {
326                                            return _serde::__private::Err(__err);
327                                        }
328                                    },
329                                );
330                            }
331                            _ => {}
332                        }
333                    }
334                    __A::pad(&mut __map, 0usize, 4usize)?;
335                    let m_source = match m_source {
336                        _serde::__private::Some(__field) => __field,
337                        _serde::__private::None => {
338                            return _serde::__private::Err(
339                                <__A::Error as _serde::de::Error>::missing_field("source"),
340                            );
341                        }
342                    };
343                    let m_target = match m_target {
344                        _serde::__private::Some(__field) => __field,
345                        _serde::__private::None => {
346                            return _serde::__private::Err(
347                                <__A::Error as _serde::de::Error>::missing_field("target"),
348                            );
349                        }
350                    };
351                    let m_result = match m_result {
352                        _serde::__private::Some(__field) => __field,
353                        _serde::__private::None => {
354                            return _serde::__private::Err(
355                                <__A::Error as _serde::de::Error>::missing_field("result"),
356                            );
357                        }
358                    };
359                    let m_gain = match m_gain {
360                        _serde::__private::Some(__field) => __field,
361                        _serde::__private::None => {
362                            return _serde::__private::Err(
363                                <__A::Error as _serde::de::Error>::missing_field("gain"),
364                            );
365                        }
366                    };
367                    let m_timeStep = match m_timeStep {
368                        _serde::__private::Some(__field) => __field,
369                        _serde::__private::None => {
370                            return _serde::__private::Err(
371                                <__A::Error as _serde::de::Error>::missing_field("timeStep"),
372                            );
373                        }
374                    };
375                    _serde::__private::Ok(BSInterpValueModifier {
376                        __ptr,
377                        parent,
378                        m_source,
379                        m_target,
380                        m_result,
381                        m_gain,
382                        m_timeStep,
383                    })
384                }
385                #[allow(clippy::manual_unwrap_or_default)]
386                fn visit_struct<__A>(
387                    self,
388                    mut __map: __A,
389                ) -> _serde::__private::Result<Self::Value, __A::Error>
390                where
391                    __A: _serde::de::MapAccess<'de>,
392                {
393                    let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
394                    let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
395                    let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
396                    let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
397                    let mut m_source: _serde::__private::Option<f32> = _serde::__private::None;
398                    let mut m_target: _serde::__private::Option<f32> = _serde::__private::None;
399                    let mut m_result: _serde::__private::Option<f32> = _serde::__private::None;
400                    let mut m_gain: _serde::__private::Option<f32> = _serde::__private::None;
401                    while let _serde::__private::Some(__key) = {
402                        __A::next_key::<__Field>(&mut __map)?
403                    } {
404                        match __key {
405                            __Field::m_variableBindingSet => {
406                                #[cfg(
407                                    any(feature = "strict", feature = "ignore_duplicates")
408                                )]
409                                if _serde::__private::Option::is_some(
410                                    &m_variableBindingSet,
411                                ) {
412                                    #[cfg(feature = "ignore_duplicates")]
413                                    {
414                                        __A::skip_value(&mut __map)?;
415                                        continue;
416                                    }
417                                    #[cfg(feature = "strict")]
418                                    return _serde::__private::Err(
419                                        <__A::Error as _serde::de::Error>::duplicate_field(
420                                            "variableBindingSet",
421                                        ),
422                                    );
423                                }
424                                m_variableBindingSet = _serde::__private::Some(
425                                    match __A::next_value::<Pointer>(&mut __map) {
426                                        _serde::__private::Ok(__val) => __val,
427                                        _serde::__private::Err(__err) => {
428                                            return _serde::__private::Err(__err);
429                                        }
430                                    },
431                                );
432                            }
433                            __Field::m_userData => {
434                                #[cfg(
435                                    any(feature = "strict", feature = "ignore_duplicates")
436                                )]
437                                if _serde::__private::Option::is_some(&m_userData) {
438                                    #[cfg(feature = "ignore_duplicates")]
439                                    {
440                                        __A::skip_value(&mut __map)?;
441                                        continue;
442                                    }
443                                    #[cfg(feature = "strict")]
444                                    return _serde::__private::Err(
445                                        <__A::Error as _serde::de::Error>::duplicate_field(
446                                            "userData",
447                                        ),
448                                    );
449                                }
450                                m_userData = _serde::__private::Some(
451                                    match __A::next_value::<Ulong>(&mut __map) {
452                                        _serde::__private::Ok(__val) => __val,
453                                        _serde::__private::Err(__err) => {
454                                            return _serde::__private::Err(__err);
455                                        }
456                                    },
457                                );
458                            }
459                            __Field::m_name => {
460                                #[cfg(
461                                    any(feature = "strict", feature = "ignore_duplicates")
462                                )]
463                                if _serde::__private::Option::is_some(&m_name) {
464                                    #[cfg(feature = "ignore_duplicates")]
465                                    {
466                                        __A::skip_value(&mut __map)?;
467                                        continue;
468                                    }
469                                    #[cfg(feature = "strict")]
470                                    return _serde::__private::Err(
471                                        <__A::Error as _serde::de::Error>::duplicate_field("name"),
472                                    );
473                                }
474                                m_name = _serde::__private::Some(
475                                    match __A::next_value::<StringPtr<'de>>(&mut __map) {
476                                        _serde::__private::Ok(__val) => __val,
477                                        _serde::__private::Err(__err) => {
478                                            return _serde::__private::Err(__err);
479                                        }
480                                    },
481                                );
482                            }
483                            __Field::m_enable => {
484                                #[cfg(
485                                    any(feature = "strict", feature = "ignore_duplicates")
486                                )]
487                                if _serde::__private::Option::is_some(&m_enable) {
488                                    #[cfg(feature = "ignore_duplicates")]
489                                    {
490                                        __A::skip_value(&mut __map)?;
491                                        continue;
492                                    }
493                                    #[cfg(feature = "strict")]
494                                    return _serde::__private::Err(
495                                        <__A::Error as _serde::de::Error>::duplicate_field("enable"),
496                                    );
497                                }
498                                m_enable = _serde::__private::Some(
499                                    match __A::next_value::<bool>(&mut __map) {
500                                        _serde::__private::Ok(__val) => __val,
501                                        _serde::__private::Err(__err) => {
502                                            return _serde::__private::Err(__err);
503                                        }
504                                    },
505                                );
506                            }
507                            __Field::m_source => {
508                                #[cfg(
509                                    any(feature = "strict", feature = "ignore_duplicates")
510                                )]
511                                if _serde::__private::Option::is_some(&m_source) {
512                                    #[cfg(feature = "ignore_duplicates")]
513                                    {
514                                        __A::skip_value(&mut __map)?;
515                                        continue;
516                                    }
517                                    #[cfg(feature = "strict")]
518                                    return _serde::__private::Err(
519                                        <__A::Error as _serde::de::Error>::duplicate_field("source"),
520                                    );
521                                }
522                                m_source = _serde::__private::Some(
523                                    match __A::next_value::<f32>(&mut __map) {
524                                        _serde::__private::Ok(__val) => __val,
525                                        _serde::__private::Err(__err) => {
526                                            return _serde::__private::Err(__err);
527                                        }
528                                    },
529                                );
530                            }
531                            __Field::m_target => {
532                                #[cfg(
533                                    any(feature = "strict", feature = "ignore_duplicates")
534                                )]
535                                if _serde::__private::Option::is_some(&m_target) {
536                                    #[cfg(feature = "ignore_duplicates")]
537                                    {
538                                        __A::skip_value(&mut __map)?;
539                                        continue;
540                                    }
541                                    #[cfg(feature = "strict")]
542                                    return _serde::__private::Err(
543                                        <__A::Error as _serde::de::Error>::duplicate_field("target"),
544                                    );
545                                }
546                                m_target = _serde::__private::Some(
547                                    match __A::next_value::<f32>(&mut __map) {
548                                        _serde::__private::Ok(__val) => __val,
549                                        _serde::__private::Err(__err) => {
550                                            return _serde::__private::Err(__err);
551                                        }
552                                    },
553                                );
554                            }
555                            __Field::m_result => {
556                                #[cfg(
557                                    any(feature = "strict", feature = "ignore_duplicates")
558                                )]
559                                if _serde::__private::Option::is_some(&m_result) {
560                                    #[cfg(feature = "ignore_duplicates")]
561                                    {
562                                        __A::skip_value(&mut __map)?;
563                                        continue;
564                                    }
565                                    #[cfg(feature = "strict")]
566                                    return _serde::__private::Err(
567                                        <__A::Error as _serde::de::Error>::duplicate_field("result"),
568                                    );
569                                }
570                                m_result = _serde::__private::Some(
571                                    match __A::next_value::<f32>(&mut __map) {
572                                        _serde::__private::Ok(__val) => __val,
573                                        _serde::__private::Err(__err) => {
574                                            return _serde::__private::Err(__err);
575                                        }
576                                    },
577                                );
578                            }
579                            __Field::m_gain => {
580                                #[cfg(
581                                    any(feature = "strict", feature = "ignore_duplicates")
582                                )]
583                                if _serde::__private::Option::is_some(&m_gain) {
584                                    #[cfg(feature = "ignore_duplicates")]
585                                    {
586                                        __A::skip_value(&mut __map)?;
587                                        continue;
588                                    }
589                                    #[cfg(feature = "strict")]
590                                    return _serde::__private::Err(
591                                        <__A::Error as _serde::de::Error>::duplicate_field("gain"),
592                                    );
593                                }
594                                m_gain = _serde::__private::Some(
595                                    match __A::next_value::<f32>(&mut __map) {
596                                        _serde::__private::Ok(__val) => __val,
597                                        _serde::__private::Err(__err) => {
598                                            return _serde::__private::Err(__err);
599                                        }
600                                    },
601                                );
602                            }
603                            _ => __A::skip_value(&mut __map)?,
604                        }
605                    }
606                    let m_variableBindingSet = match m_variableBindingSet {
607                        _serde::__private::Some(__field) => __field,
608                        _serde::__private::None => {
609                            #[cfg(feature = "strict")]
610                            return _serde::__private::Err(
611                                <__A::Error as _serde::de::Error>::missing_field(
612                                    "variableBindingSet",
613                                ),
614                            );
615                            #[cfg(not(feature = "strict"))] Default::default()
616                        }
617                    };
618                    let m_userData = match m_userData {
619                        _serde::__private::Some(__field) => __field,
620                        _serde::__private::None => {
621                            #[cfg(feature = "strict")]
622                            return _serde::__private::Err(
623                                <__A::Error as _serde::de::Error>::missing_field("userData"),
624                            );
625                            #[cfg(not(feature = "strict"))] Default::default()
626                        }
627                    };
628                    let m_name = match m_name {
629                        _serde::__private::Some(__field) => __field,
630                        _serde::__private::None => {
631                            #[cfg(feature = "strict")]
632                            return _serde::__private::Err(
633                                <__A::Error as _serde::de::Error>::missing_field("name"),
634                            );
635                            #[cfg(not(feature = "strict"))] Default::default()
636                        }
637                    };
638                    let m_enable = match m_enable {
639                        _serde::__private::Some(__field) => __field,
640                        _serde::__private::None => {
641                            #[cfg(feature = "strict")]
642                            return _serde::__private::Err(
643                                <__A::Error as _serde::de::Error>::missing_field("enable"),
644                            );
645                            #[cfg(not(feature = "strict"))] Default::default()
646                        }
647                    };
648                    let m_source = match m_source {
649                        _serde::__private::Some(__field) => __field,
650                        _serde::__private::None => {
651                            #[cfg(feature = "strict")]
652                            return _serde::__private::Err(
653                                <__A::Error as _serde::de::Error>::missing_field("source"),
654                            );
655                            #[cfg(not(feature = "strict"))] Default::default()
656                        }
657                    };
658                    let m_target = match m_target {
659                        _serde::__private::Some(__field) => __field,
660                        _serde::__private::None => {
661                            #[cfg(feature = "strict")]
662                            return _serde::__private::Err(
663                                <__A::Error as _serde::de::Error>::missing_field("target"),
664                            );
665                            #[cfg(not(feature = "strict"))] Default::default()
666                        }
667                    };
668                    let m_result = match m_result {
669                        _serde::__private::Some(__field) => __field,
670                        _serde::__private::None => {
671                            #[cfg(feature = "strict")]
672                            return _serde::__private::Err(
673                                <__A::Error as _serde::de::Error>::missing_field("result"),
674                            );
675                            #[cfg(not(feature = "strict"))] Default::default()
676                        }
677                    };
678                    let m_gain = match m_gain {
679                        _serde::__private::Some(__field) => __field,
680                        _serde::__private::None => {
681                            #[cfg(feature = "strict")]
682                            return _serde::__private::Err(
683                                <__A::Error as _serde::de::Error>::missing_field("gain"),
684                            );
685                            #[cfg(not(feature = "strict"))] Default::default()
686                        }
687                    };
688                    let __ptr = None;
689                    let parent = hkBaseObject { __ptr };
690                    let parent = hkReferencedObject {
691                        __ptr,
692                        parent,
693                        ..Default::default()
694                    };
695                    let parent = hkbBindable {
696                        __ptr,
697                        parent,
698                        m_variableBindingSet,
699                        ..Default::default()
700                    };
701                    let parent = hkbNode {
702                        __ptr,
703                        parent,
704                        m_userData,
705                        m_name,
706                        ..Default::default()
707                    };
708                    let parent = hkbModifier {
709                        __ptr,
710                        parent,
711                        m_enable,
712                        ..Default::default()
713                    };
714                    let __ptr = __A::class_ptr(&mut __map);
715                    _serde::__private::Ok(BSInterpValueModifier {
716                        __ptr,
717                        parent,
718                        m_source,
719                        m_target,
720                        m_result,
721                        m_gain,
722                        ..Default::default()
723                    })
724                }
725            }
726            const FIELDS: &[&str] = &["source", "target", "result", "gain", "timeStep"];
727            _serde::Deserializer::deserialize_struct(
728                deserializer,
729                "BSInterpValueModifier",
730                FIELDS,
731                __BSInterpValueModifierVisitor {
732                    marker: _serde::__private::PhantomData::<BSInterpValueModifier>,
733                    lifetime: _serde::__private::PhantomData,
734                },
735            )
736        }
737    }
738};
havok_classes/generated/BSInterpValueModifier_.rs

havok_classes/generated/
BSInterpValueModifier_.rs
