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 hkpCogWheelConstraintAtom {
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 = "cogWheelRadiusA"))]
35 #[cfg_attr(feature = "serde", serde(rename = "cogWheelRadiusA"))]
36 pub m_cogWheelRadiusA: f32,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "cogWheelRadiusB"))]
42 #[cfg_attr(feature = "serde", serde(rename = "cogWheelRadiusB"))]
43 pub m_cogWheelRadiusB: f32,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "isScrew"))]
49 #[cfg_attr(feature = "serde", serde(rename = "isScrew"))]
50 pub m_isScrew: bool,
51 #[cfg_attr(
56 feature = "json_schema",
57 schemars(rename = "memOffsetToInitialAngleOffset")
58 )]
59 #[cfg_attr(feature = "serde", serde(rename = "memOffsetToInitialAngleOffset"))]
60 pub m_memOffsetToInitialAngleOffset: i8,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "memOffsetToPrevAngle"))]
66 #[cfg_attr(feature = "serde", serde(rename = "memOffsetToPrevAngle"))]
67 pub m_memOffsetToPrevAngle: i8,
68 #[cfg_attr(
73 feature = "json_schema",
74 schemars(rename = "memOffsetToRevolutionCounter")
75 )]
76 #[cfg_attr(feature = "serde", serde(rename = "memOffsetToRevolutionCounter"))]
77 pub m_memOffsetToRevolutionCounter: i8,
78}
79const _: () = {
80 use havok_serde as _serde;
81 impl _serde::HavokClass for hkpCogWheelConstraintAtom {
82 #[inline]
83 fn name(&self) -> &'static str {
84 "hkpCogWheelConstraintAtom"
85 }
86 #[inline]
87 fn signature(&self) -> _serde::__private::Signature {
88 _serde::__private::Signature::new(0xf2b1f399)
89 }
90 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
91 fn deps_indexes(&self) -> Vec<usize> {
92 let mut v = Vec::new();
93 v
94 }
95 }
96 impl _serde::Serialize for hkpCogWheelConstraintAtom {
97 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
98 where
99 S: _serde::ser::Serializer,
100 {
101 let class_meta = self
102 .__ptr
103 .map(|name| (name, _serde::__private::Signature::new(0xf2b1f399)));
104 let mut serializer = __serializer
105 .serialize_struct(
106 "hkpCogWheelConstraintAtom",
107 class_meta,
108 (16u64, 16u64),
109 )?;
110 serializer.serialize_field("type", &self.parent.m_type)?;
111 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
112 serializer.serialize_field("cogWheelRadiusA", &self.m_cogWheelRadiusA)?;
113 serializer.serialize_field("cogWheelRadiusB", &self.m_cogWheelRadiusB)?;
114 serializer.serialize_field("isScrew", &self.m_isScrew)?;
115 serializer
116 .serialize_field(
117 "memOffsetToInitialAngleOffset",
118 &self.m_memOffsetToInitialAngleOffset,
119 )?;
120 serializer
121 .serialize_field("memOffsetToPrevAngle", &self.m_memOffsetToPrevAngle)?;
122 serializer
123 .serialize_field(
124 "memOffsetToRevolutionCounter",
125 &self.m_memOffsetToRevolutionCounter,
126 )?;
127 serializer.end()
128 }
129 }
130};
131#[doc(hidden)]
132#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
133const _: () = {
134 use havok_serde as _serde;
135 #[automatically_derived]
136 impl<'de> _serde::Deserialize<'de> for hkpCogWheelConstraintAtom {
137 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
138 where
139 __D: _serde::Deserializer<'de>,
140 {
141 #[allow(non_camel_case_types)]
142 enum __Field {
143 m_type,
144 m_cogWheelRadiusA,
145 m_cogWheelRadiusB,
146 m_isScrew,
147 m_memOffsetToInitialAngleOffset,
148 m_memOffsetToPrevAngle,
149 m_memOffsetToRevolutionCounter,
150 __ignore,
151 }
152 struct __FieldVisitor;
153 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
154 type Value = __Field;
155 fn expecting(
156 &self,
157 __formatter: &mut core::fmt::Formatter,
158 ) -> core::fmt::Result {
159 core::fmt::Formatter::write_str(__formatter, "field identifier")
160 }
161 #[allow(clippy::match_single_binding)]
163 #[allow(clippy::reversed_empty_ranges)]
164 #[allow(clippy::single_match)]
165 fn visit_key<__E>(
166 self,
167 __value: &str,
168 ) -> core::result::Result<Self::Value, __E>
169 where
170 __E: _serde::de::Error,
171 {
172 match __value {
173 "type" => Ok(__Field::m_type),
174 "cogWheelRadiusA" => Ok(__Field::m_cogWheelRadiusA),
175 "cogWheelRadiusB" => Ok(__Field::m_cogWheelRadiusB),
176 "isScrew" => Ok(__Field::m_isScrew),
177 "memOffsetToInitialAngleOffset" => {
178 Ok(__Field::m_memOffsetToInitialAngleOffset)
179 }
180 "memOffsetToPrevAngle" => Ok(__Field::m_memOffsetToPrevAngle),
181 "memOffsetToRevolutionCounter" => {
182 Ok(__Field::m_memOffsetToRevolutionCounter)
183 }
184 _ => Ok(__Field::__ignore),
185 }
186 }
187 }
188 impl<'de> _serde::Deserialize<'de> for __Field {
189 #[inline]
190 fn deserialize<__D>(
191 __deserializer: __D,
192 ) -> core::result::Result<Self, __D::Error>
193 where
194 __D: _serde::Deserializer<'de>,
195 {
196 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
197 }
198 }
199 struct __hkpCogWheelConstraintAtomVisitor<'de> {
200 marker: _serde::__private::PhantomData<hkpCogWheelConstraintAtom>,
201 lifetime: _serde::__private::PhantomData<&'de ()>,
202 }
203 #[allow(clippy::match_single_binding)]
204 #[allow(clippy::reversed_empty_ranges)]
205 #[allow(clippy::single_match)]
206 impl<'de> _serde::de::Visitor<'de>
207 for __hkpCogWheelConstraintAtomVisitor<'de> {
208 type Value = hkpCogWheelConstraintAtom;
209 fn expecting(
210 &self,
211 __formatter: &mut core::fmt::Formatter,
212 ) -> core::fmt::Result {
213 core::fmt::Formatter::write_str(
214 __formatter,
215 "struct hkpCogWheelConstraintAtom",
216 )
217 }
218 fn visit_struct_for_bytes<__A>(
219 self,
220 mut __map: __A,
221 ) -> _serde::__private::Result<Self::Value, __A::Error>
222 where
223 __A: _serde::de::MapAccess<'de>,
224 {
225 let __ptr = __A::class_ptr(&mut __map);
226 let parent = __A::parent_value(&mut __map)?;
227 let mut m_cogWheelRadiusA: _serde::__private::Option<f32> = _serde::__private::None;
228 let mut m_cogWheelRadiusB: _serde::__private::Option<f32> = _serde::__private::None;
229 let mut m_isScrew: _serde::__private::Option<bool> = _serde::__private::None;
230 let mut m_memOffsetToInitialAngleOffset: _serde::__private::Option<
231 i8,
232 > = _serde::__private::None;
233 let mut m_memOffsetToPrevAngle: _serde::__private::Option<i8> = _serde::__private::None;
234 let mut m_memOffsetToRevolutionCounter: _serde::__private::Option<
235 i8,
236 > = _serde::__private::None;
237 for i in 0..6usize {
238 match i {
239 0usize => {
240 if _serde::__private::Option::is_some(&m_cogWheelRadiusA) {
241 return _serde::__private::Err(
242 <__A::Error as _serde::de::Error>::duplicate_field(
243 "cogWheelRadiusA",
244 ),
245 );
246 }
247 __A::pad(&mut __map, 2usize, 2usize)?;
248 m_cogWheelRadiusA = _serde::__private::Some(
249 match __A::next_value::<f32>(&mut __map) {
250 _serde::__private::Ok(__val) => __val,
251 _serde::__private::Err(__err) => {
252 return _serde::__private::Err(__err);
253 }
254 },
255 );
256 }
257 1usize => {
258 if _serde::__private::Option::is_some(&m_cogWheelRadiusB) {
259 return _serde::__private::Err(
260 <__A::Error as _serde::de::Error>::duplicate_field(
261 "cogWheelRadiusB",
262 ),
263 );
264 }
265 m_cogWheelRadiusB = _serde::__private::Some(
266 match __A::next_value::<f32>(&mut __map) {
267 _serde::__private::Ok(__val) => __val,
268 _serde::__private::Err(__err) => {
269 return _serde::__private::Err(__err);
270 }
271 },
272 );
273 }
274 2usize => {
275 if _serde::__private::Option::is_some(&m_isScrew) {
276 return _serde::__private::Err(
277 <__A::Error as _serde::de::Error>::duplicate_field(
278 "isScrew",
279 ),
280 );
281 }
282 m_isScrew = _serde::__private::Some(
283 match __A::next_value::<bool>(&mut __map) {
284 _serde::__private::Ok(__val) => __val,
285 _serde::__private::Err(__err) => {
286 return _serde::__private::Err(__err);
287 }
288 },
289 );
290 }
291 3usize => {
292 if _serde::__private::Option::is_some(
293 &m_memOffsetToInitialAngleOffset,
294 ) {
295 return _serde::__private::Err(
296 <__A::Error as _serde::de::Error>::duplicate_field(
297 "memOffsetToInitialAngleOffset",
298 ),
299 );
300 }
301 m_memOffsetToInitialAngleOffset = _serde::__private::Some(
302 match __A::next_value::<i8>(&mut __map) {
303 _serde::__private::Ok(__val) => __val,
304 _serde::__private::Err(__err) => {
305 return _serde::__private::Err(__err);
306 }
307 },
308 );
309 }
310 4usize => {
311 if _serde::__private::Option::is_some(
312 &m_memOffsetToPrevAngle,
313 ) {
314 return _serde::__private::Err(
315 <__A::Error as _serde::de::Error>::duplicate_field(
316 "memOffsetToPrevAngle",
317 ),
318 );
319 }
320 m_memOffsetToPrevAngle = _serde::__private::Some(
321 match __A::next_value::<i8>(&mut __map) {
322 _serde::__private::Ok(__val) => __val,
323 _serde::__private::Err(__err) => {
324 return _serde::__private::Err(__err);
325 }
326 },
327 );
328 }
329 5usize => {
330 if _serde::__private::Option::is_some(
331 &m_memOffsetToRevolutionCounter,
332 ) {
333 return _serde::__private::Err(
334 <__A::Error as _serde::de::Error>::duplicate_field(
335 "memOffsetToRevolutionCounter",
336 ),
337 );
338 }
339 m_memOffsetToRevolutionCounter = _serde::__private::Some(
340 match __A::next_value::<i8>(&mut __map) {
341 _serde::__private::Ok(__val) => __val,
342 _serde::__private::Err(__err) => {
343 return _serde::__private::Err(__err);
344 }
345 },
346 );
347 }
348 _ => {}
349 }
350 }
351 let m_cogWheelRadiusA = match m_cogWheelRadiusA {
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 "cogWheelRadiusA",
357 ),
358 );
359 }
360 };
361 let m_cogWheelRadiusB = match m_cogWheelRadiusB {
362 _serde::__private::Some(__field) => __field,
363 _serde::__private::None => {
364 return _serde::__private::Err(
365 <__A::Error as _serde::de::Error>::missing_field(
366 "cogWheelRadiusB",
367 ),
368 );
369 }
370 };
371 let m_isScrew = match m_isScrew {
372 _serde::__private::Some(__field) => __field,
373 _serde::__private::None => {
374 return _serde::__private::Err(
375 <__A::Error as _serde::de::Error>::missing_field("isScrew"),
376 );
377 }
378 };
379 let m_memOffsetToInitialAngleOffset = match m_memOffsetToInitialAngleOffset {
380 _serde::__private::Some(__field) => __field,
381 _serde::__private::None => {
382 return _serde::__private::Err(
383 <__A::Error as _serde::de::Error>::missing_field(
384 "memOffsetToInitialAngleOffset",
385 ),
386 );
387 }
388 };
389 let m_memOffsetToPrevAngle = match m_memOffsetToPrevAngle {
390 _serde::__private::Some(__field) => __field,
391 _serde::__private::None => {
392 return _serde::__private::Err(
393 <__A::Error as _serde::de::Error>::missing_field(
394 "memOffsetToPrevAngle",
395 ),
396 );
397 }
398 };
399 let m_memOffsetToRevolutionCounter = match m_memOffsetToRevolutionCounter {
400 _serde::__private::Some(__field) => __field,
401 _serde::__private::None => {
402 return _serde::__private::Err(
403 <__A::Error as _serde::de::Error>::missing_field(
404 "memOffsetToRevolutionCounter",
405 ),
406 );
407 }
408 };
409 _serde::__private::Ok(hkpCogWheelConstraintAtom {
410 __ptr,
411 parent,
412 m_cogWheelRadiusA,
413 m_cogWheelRadiusB,
414 m_isScrew,
415 m_memOffsetToInitialAngleOffset,
416 m_memOffsetToPrevAngle,
417 m_memOffsetToRevolutionCounter,
418 })
419 }
420 #[allow(clippy::manual_unwrap_or_default)]
421 fn visit_struct<__A>(
422 self,
423 mut __map: __A,
424 ) -> _serde::__private::Result<Self::Value, __A::Error>
425 where
426 __A: _serde::de::MapAccess<'de>,
427 {
428 let mut m_type: _serde::__private::Option<AtomType> = _serde::__private::None;
429 let mut m_cogWheelRadiusA: _serde::__private::Option<f32> = _serde::__private::None;
430 let mut m_cogWheelRadiusB: _serde::__private::Option<f32> = _serde::__private::None;
431 let mut m_isScrew: _serde::__private::Option<bool> = _serde::__private::None;
432 let mut m_memOffsetToInitialAngleOffset: _serde::__private::Option<
433 i8,
434 > = _serde::__private::None;
435 let mut m_memOffsetToPrevAngle: _serde::__private::Option<i8> = _serde::__private::None;
436 let mut m_memOffsetToRevolutionCounter: _serde::__private::Option<
437 i8,
438 > = _serde::__private::None;
439 while let _serde::__private::Some(__key) = {
440 __A::next_key::<__Field>(&mut __map)?
441 } {
442 match __key {
443 __Field::m_type => {
444 #[cfg(
445 any(feature = "strict", feature = "ignore_duplicates")
446 )]
447 if _serde::__private::Option::is_some(&m_type) {
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("type"),
456 );
457 }
458 m_type = _serde::__private::Some(
459 match __A::next_value::<AtomType>(&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_cogWheelRadiusA => {
468 #[cfg(
469 any(feature = "strict", feature = "ignore_duplicates")
470 )]
471 if _serde::__private::Option::is_some(&m_cogWheelRadiusA) {
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 "cogWheelRadiusA",
481 ),
482 );
483 }
484 m_cogWheelRadiusA = _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_cogWheelRadiusB => {
494 #[cfg(
495 any(feature = "strict", feature = "ignore_duplicates")
496 )]
497 if _serde::__private::Option::is_some(&m_cogWheelRadiusB) {
498 #[cfg(feature = "ignore_duplicates")]
499 {
500 __A::skip_value(&mut __map)?;
501 continue;
502 }
503 #[cfg(feature = "strict")]
504 return _serde::__private::Err(
505 <__A::Error as _serde::de::Error>::duplicate_field(
506 "cogWheelRadiusB",
507 ),
508 );
509 }
510 m_cogWheelRadiusB = _serde::__private::Some(
511 match __A::next_value::<f32>(&mut __map) {
512 _serde::__private::Ok(__val) => __val,
513 _serde::__private::Err(__err) => {
514 return _serde::__private::Err(__err);
515 }
516 },
517 );
518 }
519 __Field::m_isScrew => {
520 #[cfg(
521 any(feature = "strict", feature = "ignore_duplicates")
522 )]
523 if _serde::__private::Option::is_some(&m_isScrew) {
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 "isScrew",
533 ),
534 );
535 }
536 m_isScrew = _serde::__private::Some(
537 match __A::next_value::<bool>(&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_memOffsetToInitialAngleOffset => {
546 #[cfg(
547 any(feature = "strict", feature = "ignore_duplicates")
548 )]
549 if _serde::__private::Option::is_some(
550 &m_memOffsetToInitialAngleOffset,
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 "memOffsetToInitialAngleOffset",
561 ),
562 );
563 }
564 m_memOffsetToInitialAngleOffset = _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 __Field::m_memOffsetToPrevAngle => {
574 #[cfg(
575 any(feature = "strict", feature = "ignore_duplicates")
576 )]
577 if _serde::__private::Option::is_some(
578 &m_memOffsetToPrevAngle,
579 ) {
580 #[cfg(feature = "ignore_duplicates")]
581 {
582 __A::skip_value(&mut __map)?;
583 continue;
584 }
585 #[cfg(feature = "strict")]
586 return _serde::__private::Err(
587 <__A::Error as _serde::de::Error>::duplicate_field(
588 "memOffsetToPrevAngle",
589 ),
590 );
591 }
592 m_memOffsetToPrevAngle = _serde::__private::Some(
593 match __A::next_value::<i8>(&mut __map) {
594 _serde::__private::Ok(__val) => __val,
595 _serde::__private::Err(__err) => {
596 return _serde::__private::Err(__err);
597 }
598 },
599 );
600 }
601 __Field::m_memOffsetToRevolutionCounter => {
602 #[cfg(
603 any(feature = "strict", feature = "ignore_duplicates")
604 )]
605 if _serde::__private::Option::is_some(
606 &m_memOffsetToRevolutionCounter,
607 ) {
608 #[cfg(feature = "ignore_duplicates")]
609 {
610 __A::skip_value(&mut __map)?;
611 continue;
612 }
613 #[cfg(feature = "strict")]
614 return _serde::__private::Err(
615 <__A::Error as _serde::de::Error>::duplicate_field(
616 "memOffsetToRevolutionCounter",
617 ),
618 );
619 }
620 m_memOffsetToRevolutionCounter = _serde::__private::Some(
621 match __A::next_value::<i8>(&mut __map) {
622 _serde::__private::Ok(__val) => __val,
623 _serde::__private::Err(__err) => {
624 return _serde::__private::Err(__err);
625 }
626 },
627 );
628 }
629 _ => __A::skip_value(&mut __map)?,
630 }
631 }
632 let m_type = match m_type {
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("type"),
638 );
639 #[cfg(not(feature = "strict"))] Default::default()
640 }
641 };
642 let m_cogWheelRadiusA = match m_cogWheelRadiusA {
643 _serde::__private::Some(__field) => __field,
644 _serde::__private::None => {
645 #[cfg(feature = "strict")]
646 return _serde::__private::Err(
647 <__A::Error as _serde::de::Error>::missing_field(
648 "cogWheelRadiusA",
649 ),
650 );
651 #[cfg(not(feature = "strict"))] Default::default()
652 }
653 };
654 let m_cogWheelRadiusB = match m_cogWheelRadiusB {
655 _serde::__private::Some(__field) => __field,
656 _serde::__private::None => {
657 #[cfg(feature = "strict")]
658 return _serde::__private::Err(
659 <__A::Error as _serde::de::Error>::missing_field(
660 "cogWheelRadiusB",
661 ),
662 );
663 #[cfg(not(feature = "strict"))] Default::default()
664 }
665 };
666 let m_isScrew = match m_isScrew {
667 _serde::__private::Some(__field) => __field,
668 _serde::__private::None => {
669 #[cfg(feature = "strict")]
670 return _serde::__private::Err(
671 <__A::Error as _serde::de::Error>::missing_field("isScrew"),
672 );
673 #[cfg(not(feature = "strict"))] Default::default()
674 }
675 };
676 let m_memOffsetToInitialAngleOffset = match m_memOffsetToInitialAngleOffset {
677 _serde::__private::Some(__field) => __field,
678 _serde::__private::None => {
679 #[cfg(feature = "strict")]
680 return _serde::__private::Err(
681 <__A::Error as _serde::de::Error>::missing_field(
682 "memOffsetToInitialAngleOffset",
683 ),
684 );
685 #[cfg(not(feature = "strict"))] Default::default()
686 }
687 };
688 let m_memOffsetToPrevAngle = match m_memOffsetToPrevAngle {
689 _serde::__private::Some(__field) => __field,
690 _serde::__private::None => {
691 #[cfg(feature = "strict")]
692 return _serde::__private::Err(
693 <__A::Error as _serde::de::Error>::missing_field(
694 "memOffsetToPrevAngle",
695 ),
696 );
697 #[cfg(not(feature = "strict"))] Default::default()
698 }
699 };
700 let m_memOffsetToRevolutionCounter = match m_memOffsetToRevolutionCounter {
701 _serde::__private::Some(__field) => __field,
702 _serde::__private::None => {
703 #[cfg(feature = "strict")]
704 return _serde::__private::Err(
705 <__A::Error as _serde::de::Error>::missing_field(
706 "memOffsetToRevolutionCounter",
707 ),
708 );
709 #[cfg(not(feature = "strict"))] Default::default()
710 }
711 };
712 let __ptr = None;
713 let parent = hkpConstraintAtom { __ptr, m_type };
714 let __ptr = __A::class_ptr(&mut __map);
715 _serde::__private::Ok(hkpCogWheelConstraintAtom {
716 __ptr,
717 parent,
718 m_cogWheelRadiusA,
719 m_cogWheelRadiusB,
720 m_isScrew,
721 m_memOffsetToInitialAngleOffset,
722 m_memOffsetToPrevAngle,
723 m_memOffsetToRevolutionCounter,
724 })
725 }
726 }
727 const FIELDS: &[&str] = &[
728 "cogWheelRadiusA",
729 "cogWheelRadiusB",
730 "isScrew",
731 "memOffsetToInitialAngleOffset",
732 "memOffsetToPrevAngle",
733 "memOffsetToRevolutionCounter",
734 ];
735 _serde::Deserializer::deserialize_struct(
736 deserializer,
737 "hkpCogWheelConstraintAtom",
738 FIELDS,
739 __hkpCogWheelConstraintAtomVisitor {
740 marker: _serde::__private::PhantomData::<hkpCogWheelConstraintAtom>,
741 lifetime: _serde::__private::PhantomData,
742 },
743 )
744 }
745 }
746};