havok_classes/generated/
hkbEventsFromRangeModifier_.rs

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