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