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