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 hkpConstraintAtom {
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(rename = "type"))]
31 #[cfg_attr(feature = "serde", serde(rename = "type"))]
32 pub m_type: AtomType,
33}
34const _: () = {
35 use havok_serde as _serde;
36 impl _serde::HavokClass for hkpConstraintAtom {
37 #[inline]
38 fn name(&self) -> &'static str {
39 "hkpConstraintAtom"
40 }
41 #[inline]
42 fn signature(&self) -> _serde::__private::Signature {
43 _serde::__private::Signature::new(0x59d67ef6)
44 }
45 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
46 fn deps_indexes(&self) -> Vec<usize> {
47 let mut v = Vec::new();
48 v
49 }
50 }
51 impl _serde::Serialize for hkpConstraintAtom {
52 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
53 where
54 S: _serde::ser::Serializer,
55 {
56 let class_meta = self
57 .__ptr
58 .map(|name| (name, _serde::__private::Signature::new(0x59d67ef6)));
59 let mut serializer = __serializer
60 .serialize_struct("hkpConstraintAtom", class_meta, (2u64, 2u64))?;
61 serializer.serialize_field("type", &self.m_type)?;
62 serializer.end()
63 }
64 }
65};
66#[doc(hidden)]
67#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
68const _: () = {
69 use havok_serde as _serde;
70 #[automatically_derived]
71 impl<'de> _serde::Deserialize<'de> for hkpConstraintAtom {
72 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
73 where
74 __D: _serde::Deserializer<'de>,
75 {
76 #[allow(non_camel_case_types)]
77 enum __Field {
78 m_type,
79 __ignore,
80 }
81 struct __FieldVisitor;
82 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
83 type Value = __Field;
84 fn expecting(
85 &self,
86 __formatter: &mut core::fmt::Formatter,
87 ) -> core::fmt::Result {
88 core::fmt::Formatter::write_str(__formatter, "field identifier")
89 }
90 #[allow(clippy::match_single_binding)]
92 #[allow(clippy::reversed_empty_ranges)]
93 #[allow(clippy::single_match)]
94 fn visit_key<__E>(
95 self,
96 __value: &str,
97 ) -> core::result::Result<Self::Value, __E>
98 where
99 __E: _serde::de::Error,
100 {
101 match __value {
102 "type" => Ok(__Field::m_type),
103 _ => Ok(__Field::__ignore),
104 }
105 }
106 }
107 impl<'de> _serde::Deserialize<'de> for __Field {
108 #[inline]
109 fn deserialize<__D>(
110 __deserializer: __D,
111 ) -> core::result::Result<Self, __D::Error>
112 where
113 __D: _serde::Deserializer<'de>,
114 {
115 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
116 }
117 }
118 struct __hkpConstraintAtomVisitor<'de> {
119 marker: _serde::__private::PhantomData<hkpConstraintAtom>,
120 lifetime: _serde::__private::PhantomData<&'de ()>,
121 }
122 #[allow(clippy::match_single_binding)]
123 #[allow(clippy::reversed_empty_ranges)]
124 #[allow(clippy::single_match)]
125 impl<'de> _serde::de::Visitor<'de> for __hkpConstraintAtomVisitor<'de> {
126 type Value = hkpConstraintAtom;
127 fn expecting(
128 &self,
129 __formatter: &mut core::fmt::Formatter,
130 ) -> core::fmt::Result {
131 core::fmt::Formatter::write_str(
132 __formatter,
133 "struct hkpConstraintAtom",
134 )
135 }
136 fn visit_struct_for_bytes<__A>(
137 self,
138 mut __map: __A,
139 ) -> _serde::__private::Result<Self::Value, __A::Error>
140 where
141 __A: _serde::de::MapAccess<'de>,
142 {
143 let __ptr = __A::class_ptr(&mut __map);
144 let mut m_type: _serde::__private::Option<AtomType> = _serde::__private::None;
145 for i in 0..1usize {
146 match i {
147 0usize => {
148 if _serde::__private::Option::is_some(&m_type) {
149 return _serde::__private::Err(
150 <__A::Error as _serde::de::Error>::duplicate_field("type"),
151 );
152 }
153 m_type = _serde::__private::Some(
154 match __A::next_value::<AtomType>(&mut __map) {
155 _serde::__private::Ok(__val) => __val,
156 _serde::__private::Err(__err) => {
157 return _serde::__private::Err(__err);
158 }
159 },
160 );
161 }
162 _ => {}
163 }
164 }
165 let m_type = match m_type {
166 _serde::__private::Some(__field) => __field,
167 _serde::__private::None => {
168 return _serde::__private::Err(
169 <__A::Error as _serde::de::Error>::missing_field("type"),
170 );
171 }
172 };
173 _serde::__private::Ok(hkpConstraintAtom { __ptr, m_type })
174 }
175 #[allow(clippy::manual_unwrap_or_default)]
176 fn visit_struct<__A>(
177 self,
178 mut __map: __A,
179 ) -> _serde::__private::Result<Self::Value, __A::Error>
180 where
181 __A: _serde::de::MapAccess<'de>,
182 {
183 let mut m_type: _serde::__private::Option<AtomType> = _serde::__private::None;
184 while let _serde::__private::Some(__key) = {
185 __A::next_key::<__Field>(&mut __map)?
186 } {
187 match __key {
188 __Field::m_type => {
189 #[cfg(
190 any(feature = "strict", feature = "ignore_duplicates")
191 )]
192 if _serde::__private::Option::is_some(&m_type) {
193 #[cfg(feature = "ignore_duplicates")]
194 {
195 __A::skip_value(&mut __map)?;
196 continue;
197 }
198 #[cfg(feature = "strict")]
199 return _serde::__private::Err(
200 <__A::Error as _serde::de::Error>::duplicate_field("type"),
201 );
202 }
203 m_type = _serde::__private::Some(
204 match __A::next_value::<AtomType>(&mut __map) {
205 _serde::__private::Ok(__val) => __val,
206 _serde::__private::Err(__err) => {
207 return _serde::__private::Err(__err);
208 }
209 },
210 );
211 }
212 _ => __A::skip_value(&mut __map)?,
213 }
214 }
215 let m_type = match m_type {
216 _serde::__private::Some(__field) => __field,
217 _serde::__private::None => {
218 #[cfg(feature = "strict")]
219 return _serde::__private::Err(
220 <__A::Error as _serde::de::Error>::missing_field("type"),
221 );
222 #[cfg(not(feature = "strict"))] Default::default()
223 }
224 };
225 let __ptr = __A::class_ptr(&mut __map);
226 _serde::__private::Ok(hkpConstraintAtom { __ptr, m_type })
227 }
228 }
229 const FIELDS: &[&str] = &["type"];
230 _serde::Deserializer::deserialize_struct(
231 deserializer,
232 "hkpConstraintAtom",
233 FIELDS,
234 __hkpConstraintAtomVisitor {
235 marker: _serde::__private::PhantomData::<hkpConstraintAtom>,
236 lifetime: _serde::__private::PhantomData,
237 },
238 )
239 }
240 }
241};
242#[allow(non_upper_case_globals, non_snake_case)]
245#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
246#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
247#[derive(
248 Debug,
249 Clone,
250 Default,
251 PartialEq,
252 Eq,
253 PartialOrd,
254 Ord,
255 num_derive::ToPrimitive,
256 num_derive::FromPrimitive,
257)]
258pub enum AtomType {
259 #[default]
260 TYPE_INVALID = 0isize,
261 TYPE_BRIDGE = 1isize,
262 TYPE_SET_LOCAL_TRANSFORMS = 2isize,
263 TYPE_SET_LOCAL_TRANSLATIONS = 3isize,
264 TYPE_SET_LOCAL_ROTATIONS = 4isize,
265 TYPE_BALL_SOCKET = 5isize,
266 TYPE_STIFF_SPRING = 6isize,
267 TYPE_LIN = 7isize,
268 TYPE_LIN_SOFT = 8isize,
269 TYPE_LIN_LIMIT = 9isize,
270 TYPE_LIN_FRICTION = 10isize,
271 TYPE_LIN_MOTOR = 11isize,
272 TYPE_2D_ANG = 12isize,
273 TYPE_ANG = 13isize,
274 TYPE_ANG_LIMIT = 14isize,
275 TYPE_TWIST_LIMIT = 15isize,
276 TYPE_CONE_LIMIT = 16isize,
277 TYPE_ANG_FRICTION = 17isize,
278 TYPE_ANG_MOTOR = 18isize,
279 TYPE_RAGDOLL_MOTOR = 19isize,
280 TYPE_PULLEY = 20isize,
281 TYPE_RACK_AND_PINION = 21isize,
282 TYPE_COG_WHEEL = 22isize,
283 TYPE_SETUP_STABILIZATION = 23isize,
284 TYPE_OVERWRITE_PIVOT = 24isize,
285 TYPE_CONTACT = 25isize,
286 TYPE_MODIFIER_SOFT_CONTACT = 26isize,
287 TYPE_MODIFIER_MASS_CHANGER = 27isize,
288 TYPE_MODIFIER_VISCOUS_SURFACE = 28isize,
289 TYPE_MODIFIER_MOVING_SURFACE = 29isize,
290 TYPE_MODIFIER_IGNORE_CONSTRAINT = 30isize,
291 TYPE_MODIFIER_CENTER_OF_MASS_CHANGER = 31isize,
292 TYPE_MAX = 32isize,
293}
294#[allow(non_upper_case_globals, non_snake_case)]
297#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
298#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
299#[derive(
300 Debug,
301 Clone,
302 Default,
303 PartialEq,
304 Eq,
305 PartialOrd,
306 Ord,
307 num_derive::ToPrimitive,
308 num_derive::FromPrimitive,
309)]
310pub enum SolvingMethod {
311 #[default]
312 METHOD_STABILIZED = 0isize,
313 METHOD_OLD = 1isize,
314}
315const _: () = {
316 use havok_serde as __serde;
317 impl __serde::Serialize for AtomType {
318 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
319 where
320 S: __serde::ser::Serializer,
321 {
322 let mut __serializer = __serializer.serialize_enum_flags()?;
323 match self {
324 Self::TYPE_INVALID => __serializer.serialize_field("TYPE_INVALID", &0u64),
325 Self::TYPE_BRIDGE => __serializer.serialize_field("TYPE_BRIDGE", &1u64),
326 Self::TYPE_SET_LOCAL_TRANSFORMS => {
327 __serializer.serialize_field("TYPE_SET_LOCAL_TRANSFORMS", &2u64)
328 }
329 Self::TYPE_SET_LOCAL_TRANSLATIONS => {
330 __serializer.serialize_field("TYPE_SET_LOCAL_TRANSLATIONS", &3u64)
331 }
332 Self::TYPE_SET_LOCAL_ROTATIONS => {
333 __serializer.serialize_field("TYPE_SET_LOCAL_ROTATIONS", &4u64)
334 }
335 Self::TYPE_BALL_SOCKET => {
336 __serializer.serialize_field("TYPE_BALL_SOCKET", &5u64)
337 }
338 Self::TYPE_STIFF_SPRING => {
339 __serializer.serialize_field("TYPE_STIFF_SPRING", &6u64)
340 }
341 Self::TYPE_LIN => __serializer.serialize_field("TYPE_LIN", &7u64),
342 Self::TYPE_LIN_SOFT => {
343 __serializer.serialize_field("TYPE_LIN_SOFT", &8u64)
344 }
345 Self::TYPE_LIN_LIMIT => {
346 __serializer.serialize_field("TYPE_LIN_LIMIT", &9u64)
347 }
348 Self::TYPE_LIN_FRICTION => {
349 __serializer.serialize_field("TYPE_LIN_FRICTION", &10u64)
350 }
351 Self::TYPE_LIN_MOTOR => {
352 __serializer.serialize_field("TYPE_LIN_MOTOR", &11u64)
353 }
354 Self::TYPE_2D_ANG => __serializer.serialize_field("TYPE_2D_ANG", &12u64),
355 Self::TYPE_ANG => __serializer.serialize_field("TYPE_ANG", &13u64),
356 Self::TYPE_ANG_LIMIT => {
357 __serializer.serialize_field("TYPE_ANG_LIMIT", &14u64)
358 }
359 Self::TYPE_TWIST_LIMIT => {
360 __serializer.serialize_field("TYPE_TWIST_LIMIT", &15u64)
361 }
362 Self::TYPE_CONE_LIMIT => {
363 __serializer.serialize_field("TYPE_CONE_LIMIT", &16u64)
364 }
365 Self::TYPE_ANG_FRICTION => {
366 __serializer.serialize_field("TYPE_ANG_FRICTION", &17u64)
367 }
368 Self::TYPE_ANG_MOTOR => {
369 __serializer.serialize_field("TYPE_ANG_MOTOR", &18u64)
370 }
371 Self::TYPE_RAGDOLL_MOTOR => {
372 __serializer.serialize_field("TYPE_RAGDOLL_MOTOR", &19u64)
373 }
374 Self::TYPE_PULLEY => __serializer.serialize_field("TYPE_PULLEY", &20u64),
375 Self::TYPE_RACK_AND_PINION => {
376 __serializer.serialize_field("TYPE_RACK_AND_PINION", &21u64)
377 }
378 Self::TYPE_COG_WHEEL => {
379 __serializer.serialize_field("TYPE_COG_WHEEL", &22u64)
380 }
381 Self::TYPE_SETUP_STABILIZATION => {
382 __serializer.serialize_field("TYPE_SETUP_STABILIZATION", &23u64)
383 }
384 Self::TYPE_OVERWRITE_PIVOT => {
385 __serializer.serialize_field("TYPE_OVERWRITE_PIVOT", &24u64)
386 }
387 Self::TYPE_CONTACT => {
388 __serializer.serialize_field("TYPE_CONTACT", &25u64)
389 }
390 Self::TYPE_MODIFIER_SOFT_CONTACT => {
391 __serializer.serialize_field("TYPE_MODIFIER_SOFT_CONTACT", &26u64)
392 }
393 Self::TYPE_MODIFIER_MASS_CHANGER => {
394 __serializer.serialize_field("TYPE_MODIFIER_MASS_CHANGER", &27u64)
395 }
396 Self::TYPE_MODIFIER_VISCOUS_SURFACE => {
397 __serializer.serialize_field("TYPE_MODIFIER_VISCOUS_SURFACE", &28u64)
398 }
399 Self::TYPE_MODIFIER_MOVING_SURFACE => {
400 __serializer.serialize_field("TYPE_MODIFIER_MOVING_SURFACE", &29u64)
401 }
402 Self::TYPE_MODIFIER_IGNORE_CONSTRAINT => {
403 __serializer
404 .serialize_field("TYPE_MODIFIER_IGNORE_CONSTRAINT", &30u64)
405 }
406 Self::TYPE_MODIFIER_CENTER_OF_MASS_CHANGER => {
407 __serializer
408 .serialize_field("TYPE_MODIFIER_CENTER_OF_MASS_CHANGER", &31u64)
409 }
410 Self::TYPE_MAX => __serializer.serialize_field("TYPE_MAX", &32u64),
411 }?;
412 use num_traits::ToPrimitive as _;
413 let num = self
414 .to_u16()
415 .ok_or(S::Error::custom("Failed enum AtomType to_u16"))?;
416 __serializer.serialize_bits(&num)?;
417 __serializer.end()
418 }
419 }
420};
421const _: () = {
422 use havok_serde as __serde;
423 impl __serde::Serialize for SolvingMethod {
424 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
425 where
426 S: __serde::ser::Serializer,
427 {
428 let mut __serializer = __serializer.serialize_enum_flags()?;
429 match self {
430 Self::METHOD_STABILIZED => {
431 __serializer.serialize_field("METHOD_STABILIZED", &0u64)
432 }
433 Self::METHOD_OLD => __serializer.serialize_field("METHOD_OLD", &1u64),
434 }?;
435 use num_traits::ToPrimitive as _;
436 let num = self
437 .to_u8()
438 .ok_or(S::Error::custom("Failed enum SolvingMethod to_u8"))?;
439 __serializer.serialize_bits(&num)?;
440 __serializer.end()
441 }
442 }
443};
444#[doc(hidden)]
445#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
446const _: () = {
447 #[allow(unused_extern_crates, clippy::useless_attribute)]
448 extern crate havok_serde as _serde;
449 #[automatically_derived]
450 impl<'de> _serde::Deserialize<'de> for AtomType {
451 fn deserialize<__D>(
452 __deserializer: __D,
453 ) -> _serde::__private::Result<Self, __D::Error>
454 where
455 __D: _serde::Deserializer<'de>,
456 {
457 #[allow(non_camel_case_types)]
458 #[doc(hidden)]
459 enum __Field {
460 __field0,
461 __field1,
462 __field2,
463 __field3,
464 __field4,
465 __field5,
466 __field6,
467 __field7,
468 __field8,
469 __field9,
470 __field10,
471 __field11,
472 __field12,
473 __field13,
474 __field14,
475 __field15,
476 __field16,
477 __field17,
478 __field18,
479 __field19,
480 __field20,
481 __field21,
482 __field22,
483 __field23,
484 __field24,
485 __field25,
486 __field26,
487 __field27,
488 __field28,
489 __field29,
490 __field30,
491 __field31,
492 __field32,
493 }
494 #[doc(hidden)]
495 struct __FieldVisitor;
496 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
497 type Value = __Field;
498 fn expecting(
499 &self,
500 __formatter: &mut _serde::__private::Formatter,
501 ) -> _serde::__private::fmt::Result {
502 _serde::__private::Formatter::write_str(
503 __formatter,
504 "variant identifier",
505 )
506 }
507 fn visit_uint16<__E>(
508 self,
509 __value: u16,
510 ) -> _serde::__private::Result<Self::Value, __E>
511 where
512 __E: _serde::de::Error,
513 {
514 match __value {
515 0u16 => _serde::__private::Ok(__Field::__field0),
516 1u16 => _serde::__private::Ok(__Field::__field1),
517 2u16 => _serde::__private::Ok(__Field::__field2),
518 3u16 => _serde::__private::Ok(__Field::__field3),
519 4u16 => _serde::__private::Ok(__Field::__field4),
520 5u16 => _serde::__private::Ok(__Field::__field5),
521 6u16 => _serde::__private::Ok(__Field::__field6),
522 7u16 => _serde::__private::Ok(__Field::__field7),
523 8u16 => _serde::__private::Ok(__Field::__field8),
524 9u16 => _serde::__private::Ok(__Field::__field9),
525 10u16 => _serde::__private::Ok(__Field::__field10),
526 11u16 => _serde::__private::Ok(__Field::__field11),
527 12u16 => _serde::__private::Ok(__Field::__field12),
528 13u16 => _serde::__private::Ok(__Field::__field13),
529 14u16 => _serde::__private::Ok(__Field::__field14),
530 15u16 => _serde::__private::Ok(__Field::__field15),
531 16u16 => _serde::__private::Ok(__Field::__field16),
532 17u16 => _serde::__private::Ok(__Field::__field17),
533 18u16 => _serde::__private::Ok(__Field::__field18),
534 19u16 => _serde::__private::Ok(__Field::__field19),
535 20u16 => _serde::__private::Ok(__Field::__field20),
536 21u16 => _serde::__private::Ok(__Field::__field21),
537 22u16 => _serde::__private::Ok(__Field::__field22),
538 23u16 => _serde::__private::Ok(__Field::__field23),
539 24u16 => _serde::__private::Ok(__Field::__field24),
540 25u16 => _serde::__private::Ok(__Field::__field25),
541 26u16 => _serde::__private::Ok(__Field::__field26),
542 27u16 => _serde::__private::Ok(__Field::__field27),
543 28u16 => _serde::__private::Ok(__Field::__field28),
544 29u16 => _serde::__private::Ok(__Field::__field29),
545 30u16 => _serde::__private::Ok(__Field::__field30),
546 31u16 => _serde::__private::Ok(__Field::__field31),
547 32u16 => _serde::__private::Ok(__Field::__field32),
548 _ => {
549 _serde::__private::Err(
550 _serde::de::Error::invalid_value(
551 _serde::de::Unexpected::Uint16(__value),
552 &"value(u16) of variant is one of 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32",
553 ),
554 )
555 }
556 }
557 }
558 fn visit_stringptr<__E>(
559 self,
560 __value: StringPtr<'de>,
561 ) -> _serde::__private::Result<Self::Value, __E>
562 where
563 __E: _serde::de::Error,
564 {
565 if let Some(__value) = __value.into_inner() {
566 match __value.as_ref() {
567 v if v == "0" || v.eq_ignore_ascii_case("TYPE_INVALID") => {
568 _serde::__private::Ok(__Field::__field0)
569 }
570 v if v == "1" || v.eq_ignore_ascii_case("TYPE_BRIDGE") => {
571 _serde::__private::Ok(__Field::__field1)
572 }
573 v if v == "2"
574 || v.eq_ignore_ascii_case("TYPE_SET_LOCAL_TRANSFORMS") => {
575 _serde::__private::Ok(__Field::__field2)
576 }
577 v if v == "3"
578 || v.eq_ignore_ascii_case("TYPE_SET_LOCAL_TRANSLATIONS") => {
579 _serde::__private::Ok(__Field::__field3)
580 }
581 v if v == "4"
582 || v.eq_ignore_ascii_case("TYPE_SET_LOCAL_ROTATIONS") => {
583 _serde::__private::Ok(__Field::__field4)
584 }
585 v if v == "5"
586 || v.eq_ignore_ascii_case("TYPE_BALL_SOCKET") => {
587 _serde::__private::Ok(__Field::__field5)
588 }
589 v if v == "6"
590 || v.eq_ignore_ascii_case("TYPE_STIFF_SPRING") => {
591 _serde::__private::Ok(__Field::__field6)
592 }
593 v if v == "7" || v.eq_ignore_ascii_case("TYPE_LIN") => {
594 _serde::__private::Ok(__Field::__field7)
595 }
596 v if v == "8" || v.eq_ignore_ascii_case("TYPE_LIN_SOFT") => {
597 _serde::__private::Ok(__Field::__field8)
598 }
599 v if v == "9" || v.eq_ignore_ascii_case("TYPE_LIN_LIMIT") => {
600 _serde::__private::Ok(__Field::__field9)
601 }
602 v if v == "10"
603 || v.eq_ignore_ascii_case("TYPE_LIN_FRICTION") => {
604 _serde::__private::Ok(__Field::__field10)
605 }
606 v if v == "11"
607 || v.eq_ignore_ascii_case("TYPE_LIN_MOTOR") => {
608 _serde::__private::Ok(__Field::__field11)
609 }
610 v if v == "12" || v.eq_ignore_ascii_case("TYPE_2D_ANG") => {
611 _serde::__private::Ok(__Field::__field12)
612 }
613 v if v == "13" || v.eq_ignore_ascii_case("TYPE_ANG") => {
614 _serde::__private::Ok(__Field::__field13)
615 }
616 v if v == "14"
617 || v.eq_ignore_ascii_case("TYPE_ANG_LIMIT") => {
618 _serde::__private::Ok(__Field::__field14)
619 }
620 v if v == "15"
621 || v.eq_ignore_ascii_case("TYPE_TWIST_LIMIT") => {
622 _serde::__private::Ok(__Field::__field15)
623 }
624 v if v == "16"
625 || v.eq_ignore_ascii_case("TYPE_CONE_LIMIT") => {
626 _serde::__private::Ok(__Field::__field16)
627 }
628 v if v == "17"
629 || v.eq_ignore_ascii_case("TYPE_ANG_FRICTION") => {
630 _serde::__private::Ok(__Field::__field17)
631 }
632 v if v == "18"
633 || v.eq_ignore_ascii_case("TYPE_ANG_MOTOR") => {
634 _serde::__private::Ok(__Field::__field18)
635 }
636 v if v == "19"
637 || v.eq_ignore_ascii_case("TYPE_RAGDOLL_MOTOR") => {
638 _serde::__private::Ok(__Field::__field19)
639 }
640 v if v == "20" || v.eq_ignore_ascii_case("TYPE_PULLEY") => {
641 _serde::__private::Ok(__Field::__field20)
642 }
643 v if v == "21"
644 || v.eq_ignore_ascii_case("TYPE_RACK_AND_PINION") => {
645 _serde::__private::Ok(__Field::__field21)
646 }
647 v if v == "22"
648 || v.eq_ignore_ascii_case("TYPE_COG_WHEEL") => {
649 _serde::__private::Ok(__Field::__field22)
650 }
651 v if v == "23"
652 || v.eq_ignore_ascii_case("TYPE_SETUP_STABILIZATION") => {
653 _serde::__private::Ok(__Field::__field23)
654 }
655 v if v == "24"
656 || v.eq_ignore_ascii_case("TYPE_OVERWRITE_PIVOT") => {
657 _serde::__private::Ok(__Field::__field24)
658 }
659 v if v == "25" || v.eq_ignore_ascii_case("TYPE_CONTACT") => {
660 _serde::__private::Ok(__Field::__field25)
661 }
662 v if v == "26"
663 || v.eq_ignore_ascii_case("TYPE_MODIFIER_SOFT_CONTACT") => {
664 _serde::__private::Ok(__Field::__field26)
665 }
666 v if v == "27"
667 || v.eq_ignore_ascii_case("TYPE_MODIFIER_MASS_CHANGER") => {
668 _serde::__private::Ok(__Field::__field27)
669 }
670 v if v == "28"
671 || v
672 .eq_ignore_ascii_case("TYPE_MODIFIER_VISCOUS_SURFACE") => {
673 _serde::__private::Ok(__Field::__field28)
674 }
675 v if v == "29"
676 || v
677 .eq_ignore_ascii_case("TYPE_MODIFIER_MOVING_SURFACE") => {
678 _serde::__private::Ok(__Field::__field29)
679 }
680 v if v == "30"
681 || v
682 .eq_ignore_ascii_case("TYPE_MODIFIER_IGNORE_CONSTRAINT") => {
683 _serde::__private::Ok(__Field::__field30)
684 }
685 v if v == "31"
686 || v
687 .eq_ignore_ascii_case(
688 "TYPE_MODIFIER_CENTER_OF_MASS_CHANGER",
689 ) => _serde::__private::Ok(__Field::__field31),
690 v if v == "32" || v.eq_ignore_ascii_case("TYPE_MAX") => {
691 _serde::__private::Ok(__Field::__field32)
692 }
693 _ => {
694 _serde::__private::Err(
695 _serde::de::Error::unknown_variant(&__value, VARIANTS),
696 )
697 }
698 }
699 } else {
700 _serde::__private::Err(
701 _serde::de::Error::unknown_variant("None", VARIANTS),
702 )
703 }
704 }
705 }
706 impl<'de> _serde::Deserialize<'de> for __Field {
707 #[inline]
708 fn deserialize<__D>(
709 __deserializer: __D,
710 ) -> _serde::__private::Result<Self, __D::Error>
711 where
712 __D: _serde::Deserializer<'de>,
713 {
714 _serde::Deserializer::deserialize_identifier(
715 __deserializer,
716 _serde::de::ReadEnumSize::Uint16,
717 __FieldVisitor,
718 )
719 }
720 }
721 #[doc(hidden)]
722 struct __Visitor<'de> {
723 marker: _serde::__private::PhantomData<AtomType>,
724 lifetime: _serde::__private::PhantomData<&'de ()>,
725 }
726 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
727 type Value = AtomType;
728 fn expecting(
729 &self,
730 __formatter: &mut _serde::__private::Formatter,
731 ) -> _serde::__private::fmt::Result {
732 _serde::__private::Formatter::write_str(__formatter, "enum AtomType")
733 }
734 fn visit_enum<__A>(
735 self,
736 __data: __A,
737 ) -> _serde::__private::Result<Self::Value, __A::Error>
738 where
739 __A: _serde::de::EnumAccess<'de>,
740 {
741 match _serde::de::EnumAccess::variant(__data)? {
742 (__Field::__field0, __variant) => {
743 _serde::de::VariantAccess::unit_variant(__variant)?;
744 _serde::__private::Ok(AtomType::TYPE_INVALID)
745 }
746 (__Field::__field1, __variant) => {
747 _serde::de::VariantAccess::unit_variant(__variant)?;
748 _serde::__private::Ok(AtomType::TYPE_BRIDGE)
749 }
750 (__Field::__field2, __variant) => {
751 _serde::de::VariantAccess::unit_variant(__variant)?;
752 _serde::__private::Ok(AtomType::TYPE_SET_LOCAL_TRANSFORMS)
753 }
754 (__Field::__field3, __variant) => {
755 _serde::de::VariantAccess::unit_variant(__variant)?;
756 _serde::__private::Ok(AtomType::TYPE_SET_LOCAL_TRANSLATIONS)
757 }
758 (__Field::__field4, __variant) => {
759 _serde::de::VariantAccess::unit_variant(__variant)?;
760 _serde::__private::Ok(AtomType::TYPE_SET_LOCAL_ROTATIONS)
761 }
762 (__Field::__field5, __variant) => {
763 _serde::de::VariantAccess::unit_variant(__variant)?;
764 _serde::__private::Ok(AtomType::TYPE_BALL_SOCKET)
765 }
766 (__Field::__field6, __variant) => {
767 _serde::de::VariantAccess::unit_variant(__variant)?;
768 _serde::__private::Ok(AtomType::TYPE_STIFF_SPRING)
769 }
770 (__Field::__field7, __variant) => {
771 _serde::de::VariantAccess::unit_variant(__variant)?;
772 _serde::__private::Ok(AtomType::TYPE_LIN)
773 }
774 (__Field::__field8, __variant) => {
775 _serde::de::VariantAccess::unit_variant(__variant)?;
776 _serde::__private::Ok(AtomType::TYPE_LIN_SOFT)
777 }
778 (__Field::__field9, __variant) => {
779 _serde::de::VariantAccess::unit_variant(__variant)?;
780 _serde::__private::Ok(AtomType::TYPE_LIN_LIMIT)
781 }
782 (__Field::__field10, __variant) => {
783 _serde::de::VariantAccess::unit_variant(__variant)?;
784 _serde::__private::Ok(AtomType::TYPE_LIN_FRICTION)
785 }
786 (__Field::__field11, __variant) => {
787 _serde::de::VariantAccess::unit_variant(__variant)?;
788 _serde::__private::Ok(AtomType::TYPE_LIN_MOTOR)
789 }
790 (__Field::__field12, __variant) => {
791 _serde::de::VariantAccess::unit_variant(__variant)?;
792 _serde::__private::Ok(AtomType::TYPE_2D_ANG)
793 }
794 (__Field::__field13, __variant) => {
795 _serde::de::VariantAccess::unit_variant(__variant)?;
796 _serde::__private::Ok(AtomType::TYPE_ANG)
797 }
798 (__Field::__field14, __variant) => {
799 _serde::de::VariantAccess::unit_variant(__variant)?;
800 _serde::__private::Ok(AtomType::TYPE_ANG_LIMIT)
801 }
802 (__Field::__field15, __variant) => {
803 _serde::de::VariantAccess::unit_variant(__variant)?;
804 _serde::__private::Ok(AtomType::TYPE_TWIST_LIMIT)
805 }
806 (__Field::__field16, __variant) => {
807 _serde::de::VariantAccess::unit_variant(__variant)?;
808 _serde::__private::Ok(AtomType::TYPE_CONE_LIMIT)
809 }
810 (__Field::__field17, __variant) => {
811 _serde::de::VariantAccess::unit_variant(__variant)?;
812 _serde::__private::Ok(AtomType::TYPE_ANG_FRICTION)
813 }
814 (__Field::__field18, __variant) => {
815 _serde::de::VariantAccess::unit_variant(__variant)?;
816 _serde::__private::Ok(AtomType::TYPE_ANG_MOTOR)
817 }
818 (__Field::__field19, __variant) => {
819 _serde::de::VariantAccess::unit_variant(__variant)?;
820 _serde::__private::Ok(AtomType::TYPE_RAGDOLL_MOTOR)
821 }
822 (__Field::__field20, __variant) => {
823 _serde::de::VariantAccess::unit_variant(__variant)?;
824 _serde::__private::Ok(AtomType::TYPE_PULLEY)
825 }
826 (__Field::__field21, __variant) => {
827 _serde::de::VariantAccess::unit_variant(__variant)?;
828 _serde::__private::Ok(AtomType::TYPE_RACK_AND_PINION)
829 }
830 (__Field::__field22, __variant) => {
831 _serde::de::VariantAccess::unit_variant(__variant)?;
832 _serde::__private::Ok(AtomType::TYPE_COG_WHEEL)
833 }
834 (__Field::__field23, __variant) => {
835 _serde::de::VariantAccess::unit_variant(__variant)?;
836 _serde::__private::Ok(AtomType::TYPE_SETUP_STABILIZATION)
837 }
838 (__Field::__field24, __variant) => {
839 _serde::de::VariantAccess::unit_variant(__variant)?;
840 _serde::__private::Ok(AtomType::TYPE_OVERWRITE_PIVOT)
841 }
842 (__Field::__field25, __variant) => {
843 _serde::de::VariantAccess::unit_variant(__variant)?;
844 _serde::__private::Ok(AtomType::TYPE_CONTACT)
845 }
846 (__Field::__field26, __variant) => {
847 _serde::de::VariantAccess::unit_variant(__variant)?;
848 _serde::__private::Ok(AtomType::TYPE_MODIFIER_SOFT_CONTACT)
849 }
850 (__Field::__field27, __variant) => {
851 _serde::de::VariantAccess::unit_variant(__variant)?;
852 _serde::__private::Ok(AtomType::TYPE_MODIFIER_MASS_CHANGER)
853 }
854 (__Field::__field28, __variant) => {
855 _serde::de::VariantAccess::unit_variant(__variant)?;
856 _serde::__private::Ok(
857 AtomType::TYPE_MODIFIER_VISCOUS_SURFACE,
858 )
859 }
860 (__Field::__field29, __variant) => {
861 _serde::de::VariantAccess::unit_variant(__variant)?;
862 _serde::__private::Ok(AtomType::TYPE_MODIFIER_MOVING_SURFACE)
863 }
864 (__Field::__field30, __variant) => {
865 _serde::de::VariantAccess::unit_variant(__variant)?;
866 _serde::__private::Ok(
867 AtomType::TYPE_MODIFIER_IGNORE_CONSTRAINT,
868 )
869 }
870 (__Field::__field31, __variant) => {
871 _serde::de::VariantAccess::unit_variant(__variant)?;
872 _serde::__private::Ok(
873 AtomType::TYPE_MODIFIER_CENTER_OF_MASS_CHANGER,
874 )
875 }
876 (__Field::__field32, __variant) => {
877 _serde::de::VariantAccess::unit_variant(__variant)?;
878 _serde::__private::Ok(AtomType::TYPE_MAX)
879 }
880 }
881 }
882 }
883 #[doc(hidden)]
884 const VARIANTS: &'static [&'static str] = &[
885 "TYPE_INVALID",
886 "TYPE_BRIDGE",
887 "TYPE_SET_LOCAL_TRANSFORMS",
888 "TYPE_SET_LOCAL_TRANSLATIONS",
889 "TYPE_SET_LOCAL_ROTATIONS",
890 "TYPE_BALL_SOCKET",
891 "TYPE_STIFF_SPRING",
892 "TYPE_LIN",
893 "TYPE_LIN_SOFT",
894 "TYPE_LIN_LIMIT",
895 "TYPE_LIN_FRICTION",
896 "TYPE_LIN_MOTOR",
897 "TYPE_2D_ANG",
898 "TYPE_ANG",
899 "TYPE_ANG_LIMIT",
900 "TYPE_TWIST_LIMIT",
901 "TYPE_CONE_LIMIT",
902 "TYPE_ANG_FRICTION",
903 "TYPE_ANG_MOTOR",
904 "TYPE_RAGDOLL_MOTOR",
905 "TYPE_PULLEY",
906 "TYPE_RACK_AND_PINION",
907 "TYPE_COG_WHEEL",
908 "TYPE_SETUP_STABILIZATION",
909 "TYPE_OVERWRITE_PIVOT",
910 "TYPE_CONTACT",
911 "TYPE_MODIFIER_SOFT_CONTACT",
912 "TYPE_MODIFIER_MASS_CHANGER",
913 "TYPE_MODIFIER_VISCOUS_SURFACE",
914 "TYPE_MODIFIER_MOVING_SURFACE",
915 "TYPE_MODIFIER_IGNORE_CONSTRAINT",
916 "TYPE_MODIFIER_CENTER_OF_MASS_CHANGER",
917 "TYPE_MAX",
918 ];
919 _serde::Deserializer::deserialize_enum(
920 __deserializer,
921 "AtomType",
922 VARIANTS,
923 __Visitor {
924 marker: _serde::__private::PhantomData::<AtomType>,
925 lifetime: _serde::__private::PhantomData,
926 },
927 )
928 }
929 }
930};
931#[doc(hidden)]
932#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
933const _: () = {
934 #[allow(unused_extern_crates, clippy::useless_attribute)]
935 extern crate havok_serde as _serde;
936 #[automatically_derived]
937 impl<'de> _serde::Deserialize<'de> for SolvingMethod {
938 fn deserialize<__D>(
939 __deserializer: __D,
940 ) -> _serde::__private::Result<Self, __D::Error>
941 where
942 __D: _serde::Deserializer<'de>,
943 {
944 #[allow(non_camel_case_types)]
945 #[doc(hidden)]
946 enum __Field {
947 __field0,
948 __field1,
949 }
950 #[doc(hidden)]
951 struct __FieldVisitor;
952 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
953 type Value = __Field;
954 fn expecting(
955 &self,
956 __formatter: &mut _serde::__private::Formatter,
957 ) -> _serde::__private::fmt::Result {
958 _serde::__private::Formatter::write_str(
959 __formatter,
960 "variant identifier",
961 )
962 }
963 fn visit_uint8<__E>(
964 self,
965 __value: u8,
966 ) -> _serde::__private::Result<Self::Value, __E>
967 where
968 __E: _serde::de::Error,
969 {
970 match __value {
971 0u8 => _serde::__private::Ok(__Field::__field0),
972 1u8 => _serde::__private::Ok(__Field::__field1),
973 _ => {
974 _serde::__private::Err(
975 _serde::de::Error::invalid_value(
976 _serde::de::Unexpected::Uint8(__value),
977 &"value(u8) of variant is one of 0, 1",
978 ),
979 )
980 }
981 }
982 }
983 fn visit_stringptr<__E>(
984 self,
985 __value: StringPtr<'de>,
986 ) -> _serde::__private::Result<Self::Value, __E>
987 where
988 __E: _serde::de::Error,
989 {
990 if let Some(__value) = __value.into_inner() {
991 match __value.as_ref() {
992 v if v == "0"
993 || v.eq_ignore_ascii_case("METHOD_STABILIZED") => {
994 _serde::__private::Ok(__Field::__field0)
995 }
996 v if v == "1" || v.eq_ignore_ascii_case("METHOD_OLD") => {
997 _serde::__private::Ok(__Field::__field1)
998 }
999 _ => {
1000 _serde::__private::Err(
1001 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1002 )
1003 }
1004 }
1005 } else {
1006 _serde::__private::Err(
1007 _serde::de::Error::unknown_variant("None", VARIANTS),
1008 )
1009 }
1010 }
1011 }
1012 impl<'de> _serde::Deserialize<'de> for __Field {
1013 #[inline]
1014 fn deserialize<__D>(
1015 __deserializer: __D,
1016 ) -> _serde::__private::Result<Self, __D::Error>
1017 where
1018 __D: _serde::Deserializer<'de>,
1019 {
1020 _serde::Deserializer::deserialize_identifier(
1021 __deserializer,
1022 _serde::de::ReadEnumSize::Uint8,
1023 __FieldVisitor,
1024 )
1025 }
1026 }
1027 #[doc(hidden)]
1028 struct __Visitor<'de> {
1029 marker: _serde::__private::PhantomData<SolvingMethod>,
1030 lifetime: _serde::__private::PhantomData<&'de ()>,
1031 }
1032 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1033 type Value = SolvingMethod;
1034 fn expecting(
1035 &self,
1036 __formatter: &mut _serde::__private::Formatter,
1037 ) -> _serde::__private::fmt::Result {
1038 _serde::__private::Formatter::write_str(
1039 __formatter,
1040 "enum SolvingMethod",
1041 )
1042 }
1043 fn visit_enum<__A>(
1044 self,
1045 __data: __A,
1046 ) -> _serde::__private::Result<Self::Value, __A::Error>
1047 where
1048 __A: _serde::de::EnumAccess<'de>,
1049 {
1050 match _serde::de::EnumAccess::variant(__data)? {
1051 (__Field::__field0, __variant) => {
1052 _serde::de::VariantAccess::unit_variant(__variant)?;
1053 _serde::__private::Ok(SolvingMethod::METHOD_STABILIZED)
1054 }
1055 (__Field::__field1, __variant) => {
1056 _serde::de::VariantAccess::unit_variant(__variant)?;
1057 _serde::__private::Ok(SolvingMethod::METHOD_OLD)
1058 }
1059 }
1060 }
1061 }
1062 #[doc(hidden)]
1063 const VARIANTS: &'static [&'static str] = &[
1064 "METHOD_STABILIZED",
1065 "METHOD_OLD",
1066 ];
1067 _serde::Deserializer::deserialize_enum(
1068 __deserializer,
1069 "SolvingMethod",
1070 VARIANTS,
1071 __Visitor {
1072 marker: _serde::__private::PhantomData::<SolvingMethod>,
1073 lifetime: _serde::__private::PhantomData,
1074 },
1075 )
1076 }
1077 }
1078};