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