1use super::class_requires::*;
2use super::*;
3#[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 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[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 #[cfg_attr(feature = "json_schema", schemars(rename = "inputValue"))]
36 #[cfg_attr(feature = "serde", serde(rename = "inputValue"))]
37 pub m_inputValue: f32,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "lowerBound"))]
43 #[cfg_attr(feature = "serde", serde(rename = "lowerBound"))]
44 pub m_lowerBound: f32,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "eventRanges"))]
50 #[cfg_attr(feature = "serde", serde(rename = "eventRanges"))]
51 pub m_eventRanges: Pointer,
52 #[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 #[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};