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