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 hkpCallbackConstraintMotor {
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 pub parent: hkpLimitedForceConstraintMotor,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "callbackFunc"))]
36 #[cfg_attr(feature = "serde", serde(rename = "callbackFunc"))]
37 pub m_callbackFunc: Pointer,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "callbackType"))]
43 #[cfg_attr(feature = "serde", serde(rename = "callbackType"))]
44 pub m_callbackType: CallbackType,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "userData0"))]
50 #[cfg_attr(feature = "serde", serde(rename = "userData0"))]
51 pub m_userData0: Ulong,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "userData1"))]
57 #[cfg_attr(feature = "serde", serde(rename = "userData1"))]
58 pub m_userData1: Ulong,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "userData2"))]
64 #[cfg_attr(feature = "serde", serde(rename = "userData2"))]
65 pub m_userData2: Ulong,
66}
67const _: () = {
68 use havok_serde as _serde;
69 impl _serde::HavokClass for hkpCallbackConstraintMotor {
70 #[inline]
71 fn name(&self) -> &'static str {
72 "hkpCallbackConstraintMotor"
73 }
74 #[inline]
75 fn signature(&self) -> _serde::__private::Signature {
76 _serde::__private::Signature::new(0xafcd79ad)
77 }
78 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
79 fn deps_indexes(&self) -> Vec<usize> {
80 let mut v = Vec::new();
81 v.push(self.m_callbackFunc.get());
82 v
83 }
84 }
85 impl _serde::Serialize for hkpCallbackConstraintMotor {
86 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
87 where
88 S: _serde::ser::Serializer,
89 {
90 let class_meta = self
91 .__ptr
92 .map(|name| (name, _serde::__private::Signature::new(0xafcd79ad)));
93 let mut serializer = __serializer
94 .serialize_struct(
95 "hkpCallbackConstraintMotor",
96 class_meta,
97 (40u64, 72u64),
98 )?;
99 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
100 serializer
101 .skip_field(
102 "memSizeAndFlags",
103 &self.parent.parent.parent.m_memSizeAndFlags,
104 )?;
105 serializer
106 .skip_field(
107 "referenceCount",
108 &self.parent.parent.parent.m_referenceCount,
109 )?;
110 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
111 serializer.serialize_field("type", &self.parent.parent.m_type)?;
112 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
113 serializer.serialize_field("minForce", &self.parent.m_minForce)?;
114 serializer.serialize_field("maxForce", &self.parent.m_maxForce)?;
115 serializer.skip_field("callbackFunc", &self.m_callbackFunc)?;
116 serializer.serialize_field("callbackType", &self.m_callbackType)?;
117 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
118 serializer.serialize_field("userData0", &self.m_userData0)?;
119 serializer.serialize_field("userData1", &self.m_userData1)?;
120 serializer.serialize_field("userData2", &self.m_userData2)?;
121 serializer.end()
122 }
123 }
124};
125#[doc(hidden)]
126#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
127const _: () = {
128 use havok_serde as _serde;
129 #[automatically_derived]
130 impl<'de> _serde::Deserialize<'de> for hkpCallbackConstraintMotor {
131 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
132 where
133 __D: _serde::Deserializer<'de>,
134 {
135 #[allow(non_camel_case_types)]
136 enum __Field {
137 m_type,
138 m_minForce,
139 m_maxForce,
140 m_callbackType,
141 m_userData0,
142 m_userData1,
143 m_userData2,
144 __ignore,
145 }
146 struct __FieldVisitor;
147 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
148 type Value = __Field;
149 fn expecting(
150 &self,
151 __formatter: &mut core::fmt::Formatter,
152 ) -> core::fmt::Result {
153 core::fmt::Formatter::write_str(__formatter, "field identifier")
154 }
155 #[allow(clippy::match_single_binding)]
157 #[allow(clippy::reversed_empty_ranges)]
158 #[allow(clippy::single_match)]
159 fn visit_key<__E>(
160 self,
161 __value: &str,
162 ) -> core::result::Result<Self::Value, __E>
163 where
164 __E: _serde::de::Error,
165 {
166 match __value {
167 "type" => Ok(__Field::m_type),
168 "minForce" => Ok(__Field::m_minForce),
169 "maxForce" => Ok(__Field::m_maxForce),
170 "callbackType" => Ok(__Field::m_callbackType),
171 "userData0" => Ok(__Field::m_userData0),
172 "userData1" => Ok(__Field::m_userData1),
173 "userData2" => Ok(__Field::m_userData2),
174 _ => Ok(__Field::__ignore),
175 }
176 }
177 }
178 impl<'de> _serde::Deserialize<'de> for __Field {
179 #[inline]
180 fn deserialize<__D>(
181 __deserializer: __D,
182 ) -> core::result::Result<Self, __D::Error>
183 where
184 __D: _serde::Deserializer<'de>,
185 {
186 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
187 }
188 }
189 struct __hkpCallbackConstraintMotorVisitor<'de> {
190 marker: _serde::__private::PhantomData<hkpCallbackConstraintMotor>,
191 lifetime: _serde::__private::PhantomData<&'de ()>,
192 }
193 #[allow(clippy::match_single_binding)]
194 #[allow(clippy::reversed_empty_ranges)]
195 #[allow(clippy::single_match)]
196 impl<'de> _serde::de::Visitor<'de>
197 for __hkpCallbackConstraintMotorVisitor<'de> {
198 type Value = hkpCallbackConstraintMotor;
199 fn expecting(
200 &self,
201 __formatter: &mut core::fmt::Formatter,
202 ) -> core::fmt::Result {
203 core::fmt::Formatter::write_str(
204 __formatter,
205 "struct hkpCallbackConstraintMotor",
206 )
207 }
208 fn visit_struct_for_bytes<__A>(
209 self,
210 mut __map: __A,
211 ) -> _serde::__private::Result<Self::Value, __A::Error>
212 where
213 __A: _serde::de::MapAccess<'de>,
214 {
215 let __ptr = __A::class_ptr(&mut __map);
216 let parent = __A::parent_value(&mut __map)?;
217 let mut m_callbackFunc: _serde::__private::Option<Pointer> = _serde::__private::None;
218 let mut m_callbackType: _serde::__private::Option<CallbackType> = _serde::__private::None;
219 let mut m_userData0: _serde::__private::Option<Ulong> = _serde::__private::None;
220 let mut m_userData1: _serde::__private::Option<Ulong> = _serde::__private::None;
221 let mut m_userData2: _serde::__private::Option<Ulong> = _serde::__private::None;
222 for i in 0..5usize {
223 match i {
224 0usize => {
225 if _serde::__private::Option::is_some(&m_callbackFunc) {
226 return _serde::__private::Err(
227 <__A::Error as _serde::de::Error>::duplicate_field(
228 "callbackFunc",
229 ),
230 );
231 }
232 m_callbackFunc = _serde::__private::Some(
233 match __A::next_value::<Pointer>(&mut __map) {
234 _serde::__private::Ok(__val) => __val,
235 _serde::__private::Err(__err) => {
236 return _serde::__private::Err(__err);
237 }
238 },
239 );
240 }
241 1usize => {
242 if _serde::__private::Option::is_some(&m_callbackType) {
243 return _serde::__private::Err(
244 <__A::Error as _serde::de::Error>::duplicate_field(
245 "callbackType",
246 ),
247 );
248 }
249 m_callbackType = _serde::__private::Some(
250 match __A::next_value::<CallbackType>(&mut __map) {
251 _serde::__private::Ok(__val) => __val,
252 _serde::__private::Err(__err) => {
253 return _serde::__private::Err(__err);
254 }
255 },
256 );
257 }
258 2usize => {
259 if _serde::__private::Option::is_some(&m_userData0) {
260 return _serde::__private::Err(
261 <__A::Error as _serde::de::Error>::duplicate_field(
262 "userData0",
263 ),
264 );
265 }
266 __A::pad(&mut __map, 0usize, 4usize)?;
267 m_userData0 = _serde::__private::Some(
268 match __A::next_value::<Ulong>(&mut __map) {
269 _serde::__private::Ok(__val) => __val,
270 _serde::__private::Err(__err) => {
271 return _serde::__private::Err(__err);
272 }
273 },
274 );
275 }
276 3usize => {
277 if _serde::__private::Option::is_some(&m_userData1) {
278 return _serde::__private::Err(
279 <__A::Error as _serde::de::Error>::duplicate_field(
280 "userData1",
281 ),
282 );
283 }
284 m_userData1 = _serde::__private::Some(
285 match __A::next_value::<Ulong>(&mut __map) {
286 _serde::__private::Ok(__val) => __val,
287 _serde::__private::Err(__err) => {
288 return _serde::__private::Err(__err);
289 }
290 },
291 );
292 }
293 4usize => {
294 if _serde::__private::Option::is_some(&m_userData2) {
295 return _serde::__private::Err(
296 <__A::Error as _serde::de::Error>::duplicate_field(
297 "userData2",
298 ),
299 );
300 }
301 m_userData2 = _serde::__private::Some(
302 match __A::next_value::<Ulong>(&mut __map) {
303 _serde::__private::Ok(__val) => __val,
304 _serde::__private::Err(__err) => {
305 return _serde::__private::Err(__err);
306 }
307 },
308 );
309 }
310 _ => {}
311 }
312 }
313 let m_callbackFunc = match m_callbackFunc {
314 _serde::__private::Some(__field) => __field,
315 _serde::__private::None => {
316 return _serde::__private::Err(
317 <__A::Error as _serde::de::Error>::missing_field(
318 "callbackFunc",
319 ),
320 );
321 }
322 };
323 let m_callbackType = match m_callbackType {
324 _serde::__private::Some(__field) => __field,
325 _serde::__private::None => {
326 return _serde::__private::Err(
327 <__A::Error as _serde::de::Error>::missing_field(
328 "callbackType",
329 ),
330 );
331 }
332 };
333 let m_userData0 = match m_userData0 {
334 _serde::__private::Some(__field) => __field,
335 _serde::__private::None => {
336 return _serde::__private::Err(
337 <__A::Error as _serde::de::Error>::missing_field(
338 "userData0",
339 ),
340 );
341 }
342 };
343 let m_userData1 = match m_userData1 {
344 _serde::__private::Some(__field) => __field,
345 _serde::__private::None => {
346 return _serde::__private::Err(
347 <__A::Error as _serde::de::Error>::missing_field(
348 "userData1",
349 ),
350 );
351 }
352 };
353 let m_userData2 = match m_userData2 {
354 _serde::__private::Some(__field) => __field,
355 _serde::__private::None => {
356 return _serde::__private::Err(
357 <__A::Error as _serde::de::Error>::missing_field(
358 "userData2",
359 ),
360 );
361 }
362 };
363 _serde::__private::Ok(hkpCallbackConstraintMotor {
364 __ptr,
365 parent,
366 m_callbackFunc,
367 m_callbackType,
368 m_userData0,
369 m_userData1,
370 m_userData2,
371 })
372 }
373 #[allow(clippy::manual_unwrap_or_default)]
374 fn visit_struct<__A>(
375 self,
376 mut __map: __A,
377 ) -> _serde::__private::Result<Self::Value, __A::Error>
378 where
379 __A: _serde::de::MapAccess<'de>,
380 {
381 let mut m_type: _serde::__private::Option<MotorType> = _serde::__private::None;
382 let mut m_minForce: _serde::__private::Option<f32> = _serde::__private::None;
383 let mut m_maxForce: _serde::__private::Option<f32> = _serde::__private::None;
384 let mut m_callbackType: _serde::__private::Option<CallbackType> = _serde::__private::None;
385 let mut m_userData0: _serde::__private::Option<Ulong> = _serde::__private::None;
386 let mut m_userData1: _serde::__private::Option<Ulong> = _serde::__private::None;
387 let mut m_userData2: _serde::__private::Option<Ulong> = _serde::__private::None;
388 while let _serde::__private::Some(__key) = {
389 __A::next_key::<__Field>(&mut __map)?
390 } {
391 match __key {
392 __Field::m_type => {
393 #[cfg(
394 any(feature = "strict", feature = "ignore_duplicates")
395 )]
396 if _serde::__private::Option::is_some(&m_type) {
397 #[cfg(feature = "ignore_duplicates")]
398 {
399 __A::skip_value(&mut __map)?;
400 continue;
401 }
402 #[cfg(feature = "strict")]
403 return _serde::__private::Err(
404 <__A::Error as _serde::de::Error>::duplicate_field("type"),
405 );
406 }
407 m_type = _serde::__private::Some(
408 match __A::next_value::<MotorType>(&mut __map) {
409 _serde::__private::Ok(__val) => __val,
410 _serde::__private::Err(__err) => {
411 return _serde::__private::Err(__err);
412 }
413 },
414 );
415 }
416 __Field::m_minForce => {
417 #[cfg(
418 any(feature = "strict", feature = "ignore_duplicates")
419 )]
420 if _serde::__private::Option::is_some(&m_minForce) {
421 #[cfg(feature = "ignore_duplicates")]
422 {
423 __A::skip_value(&mut __map)?;
424 continue;
425 }
426 #[cfg(feature = "strict")]
427 return _serde::__private::Err(
428 <__A::Error as _serde::de::Error>::duplicate_field(
429 "minForce",
430 ),
431 );
432 }
433 m_minForce = _serde::__private::Some(
434 match __A::next_value::<f32>(&mut __map) {
435 _serde::__private::Ok(__val) => __val,
436 _serde::__private::Err(__err) => {
437 return _serde::__private::Err(__err);
438 }
439 },
440 );
441 }
442 __Field::m_maxForce => {
443 #[cfg(
444 any(feature = "strict", feature = "ignore_duplicates")
445 )]
446 if _serde::__private::Option::is_some(&m_maxForce) {
447 #[cfg(feature = "ignore_duplicates")]
448 {
449 __A::skip_value(&mut __map)?;
450 continue;
451 }
452 #[cfg(feature = "strict")]
453 return _serde::__private::Err(
454 <__A::Error as _serde::de::Error>::duplicate_field(
455 "maxForce",
456 ),
457 );
458 }
459 m_maxForce = _serde::__private::Some(
460 match __A::next_value::<f32>(&mut __map) {
461 _serde::__private::Ok(__val) => __val,
462 _serde::__private::Err(__err) => {
463 return _serde::__private::Err(__err);
464 }
465 },
466 );
467 }
468 __Field::m_callbackType => {
469 #[cfg(
470 any(feature = "strict", feature = "ignore_duplicates")
471 )]
472 if _serde::__private::Option::is_some(&m_callbackType) {
473 #[cfg(feature = "ignore_duplicates")]
474 {
475 __A::skip_value(&mut __map)?;
476 continue;
477 }
478 #[cfg(feature = "strict")]
479 return _serde::__private::Err(
480 <__A::Error as _serde::de::Error>::duplicate_field(
481 "callbackType",
482 ),
483 );
484 }
485 m_callbackType = _serde::__private::Some(
486 match __A::next_value::<CallbackType>(&mut __map) {
487 _serde::__private::Ok(__val) => __val,
488 _serde::__private::Err(__err) => {
489 return _serde::__private::Err(__err);
490 }
491 },
492 );
493 }
494 __Field::m_userData0 => {
495 #[cfg(
496 any(feature = "strict", feature = "ignore_duplicates")
497 )]
498 if _serde::__private::Option::is_some(&m_userData0) {
499 #[cfg(feature = "ignore_duplicates")]
500 {
501 __A::skip_value(&mut __map)?;
502 continue;
503 }
504 #[cfg(feature = "strict")]
505 return _serde::__private::Err(
506 <__A::Error as _serde::de::Error>::duplicate_field(
507 "userData0",
508 ),
509 );
510 }
511 m_userData0 = _serde::__private::Some(
512 match __A::next_value::<Ulong>(&mut __map) {
513 _serde::__private::Ok(__val) => __val,
514 _serde::__private::Err(__err) => {
515 return _serde::__private::Err(__err);
516 }
517 },
518 );
519 }
520 __Field::m_userData1 => {
521 #[cfg(
522 any(feature = "strict", feature = "ignore_duplicates")
523 )]
524 if _serde::__private::Option::is_some(&m_userData1) {
525 #[cfg(feature = "ignore_duplicates")]
526 {
527 __A::skip_value(&mut __map)?;
528 continue;
529 }
530 #[cfg(feature = "strict")]
531 return _serde::__private::Err(
532 <__A::Error as _serde::de::Error>::duplicate_field(
533 "userData1",
534 ),
535 );
536 }
537 m_userData1 = _serde::__private::Some(
538 match __A::next_value::<Ulong>(&mut __map) {
539 _serde::__private::Ok(__val) => __val,
540 _serde::__private::Err(__err) => {
541 return _serde::__private::Err(__err);
542 }
543 },
544 );
545 }
546 __Field::m_userData2 => {
547 #[cfg(
548 any(feature = "strict", feature = "ignore_duplicates")
549 )]
550 if _serde::__private::Option::is_some(&m_userData2) {
551 #[cfg(feature = "ignore_duplicates")]
552 {
553 __A::skip_value(&mut __map)?;
554 continue;
555 }
556 #[cfg(feature = "strict")]
557 return _serde::__private::Err(
558 <__A::Error as _serde::de::Error>::duplicate_field(
559 "userData2",
560 ),
561 );
562 }
563 m_userData2 = _serde::__private::Some(
564 match __A::next_value::<Ulong>(&mut __map) {
565 _serde::__private::Ok(__val) => __val,
566 _serde::__private::Err(__err) => {
567 return _serde::__private::Err(__err);
568 }
569 },
570 );
571 }
572 _ => __A::skip_value(&mut __map)?,
573 }
574 }
575 let m_type = match m_type {
576 _serde::__private::Some(__field) => __field,
577 _serde::__private::None => {
578 #[cfg(feature = "strict")]
579 return _serde::__private::Err(
580 <__A::Error as _serde::de::Error>::missing_field("type"),
581 );
582 #[cfg(not(feature = "strict"))] Default::default()
583 }
584 };
585 let m_minForce = match m_minForce {
586 _serde::__private::Some(__field) => __field,
587 _serde::__private::None => {
588 #[cfg(feature = "strict")]
589 return _serde::__private::Err(
590 <__A::Error as _serde::de::Error>::missing_field("minForce"),
591 );
592 #[cfg(not(feature = "strict"))] Default::default()
593 }
594 };
595 let m_maxForce = match m_maxForce {
596 _serde::__private::Some(__field) => __field,
597 _serde::__private::None => {
598 #[cfg(feature = "strict")]
599 return _serde::__private::Err(
600 <__A::Error as _serde::de::Error>::missing_field("maxForce"),
601 );
602 #[cfg(not(feature = "strict"))] Default::default()
603 }
604 };
605 let m_callbackType = match m_callbackType {
606 _serde::__private::Some(__field) => __field,
607 _serde::__private::None => {
608 #[cfg(feature = "strict")]
609 return _serde::__private::Err(
610 <__A::Error as _serde::de::Error>::missing_field(
611 "callbackType",
612 ),
613 );
614 #[cfg(not(feature = "strict"))] Default::default()
615 }
616 };
617 let m_userData0 = match m_userData0 {
618 _serde::__private::Some(__field) => __field,
619 _serde::__private::None => {
620 #[cfg(feature = "strict")]
621 return _serde::__private::Err(
622 <__A::Error as _serde::de::Error>::missing_field(
623 "userData0",
624 ),
625 );
626 #[cfg(not(feature = "strict"))] Default::default()
627 }
628 };
629 let m_userData1 = match m_userData1 {
630 _serde::__private::Some(__field) => __field,
631 _serde::__private::None => {
632 #[cfg(feature = "strict")]
633 return _serde::__private::Err(
634 <__A::Error as _serde::de::Error>::missing_field(
635 "userData1",
636 ),
637 );
638 #[cfg(not(feature = "strict"))] Default::default()
639 }
640 };
641 let m_userData2 = match m_userData2 {
642 _serde::__private::Some(__field) => __field,
643 _serde::__private::None => {
644 #[cfg(feature = "strict")]
645 return _serde::__private::Err(
646 <__A::Error as _serde::de::Error>::missing_field(
647 "userData2",
648 ),
649 );
650 #[cfg(not(feature = "strict"))] Default::default()
651 }
652 };
653 let __ptr = None;
654 let parent = hkBaseObject { __ptr };
655 let parent = hkReferencedObject {
656 __ptr,
657 parent,
658 ..Default::default()
659 };
660 let parent = hkpConstraintMotor {
661 __ptr,
662 parent,
663 m_type,
664 };
665 let parent = hkpLimitedForceConstraintMotor {
666 __ptr,
667 parent,
668 m_minForce,
669 m_maxForce,
670 };
671 let __ptr = __A::class_ptr(&mut __map);
672 _serde::__private::Ok(hkpCallbackConstraintMotor {
673 __ptr,
674 parent,
675 m_callbackType,
676 m_userData0,
677 m_userData1,
678 m_userData2,
679 ..Default::default()
680 })
681 }
682 }
683 const FIELDS: &[&str] = &[
684 "callbackFunc",
685 "callbackType",
686 "userData0",
687 "userData1",
688 "userData2",
689 ];
690 _serde::Deserializer::deserialize_struct(
691 deserializer,
692 "hkpCallbackConstraintMotor",
693 FIELDS,
694 __hkpCallbackConstraintMotorVisitor {
695 marker: _serde::__private::PhantomData::<hkpCallbackConstraintMotor>,
696 lifetime: _serde::__private::PhantomData,
697 },
698 )
699 }
700 }
701};
702#[allow(non_upper_case_globals, non_snake_case)]
705#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
706#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
707#[derive(
708 Debug,
709 Clone,
710 Default,
711 PartialEq,
712 Eq,
713 PartialOrd,
714 Ord,
715 num_derive::ToPrimitive,
716 num_derive::FromPrimitive,
717)]
718pub enum CallbackType {
719 #[default]
720 CALLBACK_MOTOR_TYPE_HAVOK_DEMO_SPRING_DAMPER = 0isize,
721 CALLBACK_MOTOR_TYPE_USER_0 = 1isize,
722 CALLBACK_MOTOR_TYPE_USER_1 = 2isize,
723 CALLBACK_MOTOR_TYPE_USER_2 = 3isize,
724 CALLBACK_MOTOR_TYPE_USER_3 = 4isize,
725}
726const _: () = {
727 use havok_serde as __serde;
728 impl __serde::Serialize for CallbackType {
729 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
730 where
731 S: __serde::ser::Serializer,
732 {
733 let mut __serializer = __serializer.serialize_enum_flags()?;
734 match self {
735 Self::CALLBACK_MOTOR_TYPE_HAVOK_DEMO_SPRING_DAMPER => {
736 __serializer
737 .serialize_field(
738 "CALLBACK_MOTOR_TYPE_HAVOK_DEMO_SPRING_DAMPER",
739 &0u64,
740 )
741 }
742 Self::CALLBACK_MOTOR_TYPE_USER_0 => {
743 __serializer.serialize_field("CALLBACK_MOTOR_TYPE_USER_0", &1u64)
744 }
745 Self::CALLBACK_MOTOR_TYPE_USER_1 => {
746 __serializer.serialize_field("CALLBACK_MOTOR_TYPE_USER_1", &2u64)
747 }
748 Self::CALLBACK_MOTOR_TYPE_USER_2 => {
749 __serializer.serialize_field("CALLBACK_MOTOR_TYPE_USER_2", &3u64)
750 }
751 Self::CALLBACK_MOTOR_TYPE_USER_3 => {
752 __serializer.serialize_field("CALLBACK_MOTOR_TYPE_USER_3", &4u64)
753 }
754 }?;
755 use num_traits::ToPrimitive as _;
756 let num = self
757 .to_u32()
758 .ok_or(S::Error::custom("Failed enum CallbackType to_u32"))?;
759 __serializer.serialize_bits(&num)?;
760 __serializer.end()
761 }
762 }
763};
764#[doc(hidden)]
765#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
766const _: () = {
767 #[allow(unused_extern_crates, clippy::useless_attribute)]
768 extern crate havok_serde as _serde;
769 #[automatically_derived]
770 impl<'de> _serde::Deserialize<'de> for CallbackType {
771 fn deserialize<__D>(
772 __deserializer: __D,
773 ) -> _serde::__private::Result<Self, __D::Error>
774 where
775 __D: _serde::Deserializer<'de>,
776 {
777 #[allow(non_camel_case_types)]
778 #[doc(hidden)]
779 enum __Field {
780 __field0,
781 __field1,
782 __field2,
783 __field3,
784 __field4,
785 }
786 #[doc(hidden)]
787 struct __FieldVisitor;
788 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
789 type Value = __Field;
790 fn expecting(
791 &self,
792 __formatter: &mut _serde::__private::Formatter,
793 ) -> _serde::__private::fmt::Result {
794 _serde::__private::Formatter::write_str(
795 __formatter,
796 "variant identifier",
797 )
798 }
799 fn visit_uint32<__E>(
800 self,
801 __value: u32,
802 ) -> _serde::__private::Result<Self::Value, __E>
803 where
804 __E: _serde::de::Error,
805 {
806 match __value {
807 0u32 => _serde::__private::Ok(__Field::__field0),
808 1u32 => _serde::__private::Ok(__Field::__field1),
809 2u32 => _serde::__private::Ok(__Field::__field2),
810 3u32 => _serde::__private::Ok(__Field::__field3),
811 4u32 => _serde::__private::Ok(__Field::__field4),
812 _ => {
813 _serde::__private::Err(
814 _serde::de::Error::invalid_value(
815 _serde::de::Unexpected::Uint32(__value),
816 &"value(u32) of variant is one of 0, 1, 2, 3, 4",
817 ),
818 )
819 }
820 }
821 }
822 fn visit_stringptr<__E>(
823 self,
824 __value: StringPtr<'de>,
825 ) -> _serde::__private::Result<Self::Value, __E>
826 where
827 __E: _serde::de::Error,
828 {
829 if let Some(__value) = __value.into_inner() {
830 match __value.as_ref() {
831 v if v == "0"
832 || v
833 .eq_ignore_ascii_case(
834 "CALLBACK_MOTOR_TYPE_HAVOK_DEMO_SPRING_DAMPER",
835 ) => _serde::__private::Ok(__Field::__field0),
836 v if v == "1"
837 || v.eq_ignore_ascii_case("CALLBACK_MOTOR_TYPE_USER_0") => {
838 _serde::__private::Ok(__Field::__field1)
839 }
840 v if v == "2"
841 || v.eq_ignore_ascii_case("CALLBACK_MOTOR_TYPE_USER_1") => {
842 _serde::__private::Ok(__Field::__field2)
843 }
844 v if v == "3"
845 || v.eq_ignore_ascii_case("CALLBACK_MOTOR_TYPE_USER_2") => {
846 _serde::__private::Ok(__Field::__field3)
847 }
848 v if v == "4"
849 || v.eq_ignore_ascii_case("CALLBACK_MOTOR_TYPE_USER_3") => {
850 _serde::__private::Ok(__Field::__field4)
851 }
852 _ => {
853 _serde::__private::Err(
854 _serde::de::Error::unknown_variant(&__value, VARIANTS),
855 )
856 }
857 }
858 } else {
859 _serde::__private::Err(
860 _serde::de::Error::unknown_variant("None", VARIANTS),
861 )
862 }
863 }
864 }
865 impl<'de> _serde::Deserialize<'de> for __Field {
866 #[inline]
867 fn deserialize<__D>(
868 __deserializer: __D,
869 ) -> _serde::__private::Result<Self, __D::Error>
870 where
871 __D: _serde::Deserializer<'de>,
872 {
873 _serde::Deserializer::deserialize_identifier(
874 __deserializer,
875 _serde::de::ReadEnumSize::Uint32,
876 __FieldVisitor,
877 )
878 }
879 }
880 #[doc(hidden)]
881 struct __Visitor<'de> {
882 marker: _serde::__private::PhantomData<CallbackType>,
883 lifetime: _serde::__private::PhantomData<&'de ()>,
884 }
885 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
886 type Value = CallbackType;
887 fn expecting(
888 &self,
889 __formatter: &mut _serde::__private::Formatter,
890 ) -> _serde::__private::fmt::Result {
891 _serde::__private::Formatter::write_str(
892 __formatter,
893 "enum CallbackType",
894 )
895 }
896 fn visit_enum<__A>(
897 self,
898 __data: __A,
899 ) -> _serde::__private::Result<Self::Value, __A::Error>
900 where
901 __A: _serde::de::EnumAccess<'de>,
902 {
903 match _serde::de::EnumAccess::variant(__data)? {
904 (__Field::__field0, __variant) => {
905 _serde::de::VariantAccess::unit_variant(__variant)?;
906 _serde::__private::Ok(
907 CallbackType::CALLBACK_MOTOR_TYPE_HAVOK_DEMO_SPRING_DAMPER,
908 )
909 }
910 (__Field::__field1, __variant) => {
911 _serde::de::VariantAccess::unit_variant(__variant)?;
912 _serde::__private::Ok(
913 CallbackType::CALLBACK_MOTOR_TYPE_USER_0,
914 )
915 }
916 (__Field::__field2, __variant) => {
917 _serde::de::VariantAccess::unit_variant(__variant)?;
918 _serde::__private::Ok(
919 CallbackType::CALLBACK_MOTOR_TYPE_USER_1,
920 )
921 }
922 (__Field::__field3, __variant) => {
923 _serde::de::VariantAccess::unit_variant(__variant)?;
924 _serde::__private::Ok(
925 CallbackType::CALLBACK_MOTOR_TYPE_USER_2,
926 )
927 }
928 (__Field::__field4, __variant) => {
929 _serde::de::VariantAccess::unit_variant(__variant)?;
930 _serde::__private::Ok(
931 CallbackType::CALLBACK_MOTOR_TYPE_USER_3,
932 )
933 }
934 }
935 }
936 }
937 #[doc(hidden)]
938 const VARIANTS: &'static [&'static str] = &[
939 "CALLBACK_MOTOR_TYPE_HAVOK_DEMO_SPRING_DAMPER",
940 "CALLBACK_MOTOR_TYPE_USER_0",
941 "CALLBACK_MOTOR_TYPE_USER_1",
942 "CALLBACK_MOTOR_TYPE_USER_2",
943 "CALLBACK_MOTOR_TYPE_USER_3",
944 ];
945 _serde::Deserializer::deserialize_enum(
946 __deserializer,
947 "CallbackType",
948 VARIANTS,
949 __Visitor {
950 marker: _serde::__private::PhantomData::<CallbackType>,
951 lifetime: _serde::__private::PhantomData,
952 },
953 )
954 }
955 }
956};