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