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 hkbFootIkGains {
15 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[cfg_attr(feature = "json_schema", schemars(rename = "onOffGain"))]
31 #[cfg_attr(feature = "serde", serde(rename = "onOffGain"))]
32 pub m_onOffGain: f32,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "groundAscendingGain"))]
38 #[cfg_attr(feature = "serde", serde(rename = "groundAscendingGain"))]
39 pub m_groundAscendingGain: f32,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "groundDescendingGain"))]
45 #[cfg_attr(feature = "serde", serde(rename = "groundDescendingGain"))]
46 pub m_groundDescendingGain: f32,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "footPlantedGain"))]
52 #[cfg_attr(feature = "serde", serde(rename = "footPlantedGain"))]
53 pub m_footPlantedGain: f32,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "footRaisedGain"))]
59 #[cfg_attr(feature = "serde", serde(rename = "footRaisedGain"))]
60 pub m_footRaisedGain: f32,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "footUnlockGain"))]
66 #[cfg_attr(feature = "serde", serde(rename = "footUnlockGain"))]
67 pub m_footUnlockGain: f32,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "worldFromModelFeedbackGain"))]
73 #[cfg_attr(feature = "serde", serde(rename = "worldFromModelFeedbackGain"))]
74 pub m_worldFromModelFeedbackGain: f32,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "errorUpDownBias"))]
80 #[cfg_attr(feature = "serde", serde(rename = "errorUpDownBias"))]
81 pub m_errorUpDownBias: f32,
82 #[cfg_attr(feature = "json_schema", schemars(rename = "alignWorldFromModelGain"))]
87 #[cfg_attr(feature = "serde", serde(rename = "alignWorldFromModelGain"))]
88 pub m_alignWorldFromModelGain: f32,
89 #[cfg_attr(feature = "json_schema", schemars(rename = "hipOrientationGain"))]
94 #[cfg_attr(feature = "serde", serde(rename = "hipOrientationGain"))]
95 pub m_hipOrientationGain: f32,
96 #[cfg_attr(feature = "json_schema", schemars(rename = "maxKneeAngleDifference"))]
101 #[cfg_attr(feature = "serde", serde(rename = "maxKneeAngleDifference"))]
102 pub m_maxKneeAngleDifference: f32,
103 #[cfg_attr(feature = "json_schema", schemars(rename = "ankleOrientationGain"))]
108 #[cfg_attr(feature = "serde", serde(rename = "ankleOrientationGain"))]
109 pub m_ankleOrientationGain: f32,
110}
111const _: () = {
112 use havok_serde as _serde;
113 impl _serde::HavokClass for hkbFootIkGains {
114 #[inline]
115 fn name(&self) -> &'static str {
116 "hkbFootIkGains"
117 }
118 #[inline]
119 fn signature(&self) -> _serde::__private::Signature {
120 _serde::__private::Signature::new(0xa681b7f0)
121 }
122 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
123 fn deps_indexes(&self) -> Vec<usize> {
124 let mut v = Vec::new();
125 v
126 }
127 }
128 impl _serde::Serialize for hkbFootIkGains {
129 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
130 where
131 S: _serde::ser::Serializer,
132 {
133 let class_meta = self
134 .__ptr
135 .map(|name| (name, _serde::__private::Signature::new(0xa681b7f0)));
136 let mut serializer = __serializer
137 .serialize_struct("hkbFootIkGains", class_meta, (48u64, 48u64))?;
138 serializer.serialize_field("onOffGain", &self.m_onOffGain)?;
139 serializer
140 .serialize_field("groundAscendingGain", &self.m_groundAscendingGain)?;
141 serializer
142 .serialize_field("groundDescendingGain", &self.m_groundDescendingGain)?;
143 serializer.serialize_field("footPlantedGain", &self.m_footPlantedGain)?;
144 serializer.serialize_field("footRaisedGain", &self.m_footRaisedGain)?;
145 serializer.serialize_field("footUnlockGain", &self.m_footUnlockGain)?;
146 serializer
147 .serialize_field(
148 "worldFromModelFeedbackGain",
149 &self.m_worldFromModelFeedbackGain,
150 )?;
151 serializer.serialize_field("errorUpDownBias", &self.m_errorUpDownBias)?;
152 serializer
153 .serialize_field(
154 "alignWorldFromModelGain",
155 &self.m_alignWorldFromModelGain,
156 )?;
157 serializer
158 .serialize_field("hipOrientationGain", &self.m_hipOrientationGain)?;
159 serializer
160 .serialize_field(
161 "maxKneeAngleDifference",
162 &self.m_maxKneeAngleDifference,
163 )?;
164 serializer
165 .serialize_field("ankleOrientationGain", &self.m_ankleOrientationGain)?;
166 serializer.end()
167 }
168 }
169};
170#[doc(hidden)]
171#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
172const _: () = {
173 use havok_serde as _serde;
174 #[automatically_derived]
175 impl<'de> _serde::Deserialize<'de> for hkbFootIkGains {
176 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
177 where
178 __D: _serde::Deserializer<'de>,
179 {
180 #[allow(non_camel_case_types)]
181 enum __Field {
182 m_onOffGain,
183 m_groundAscendingGain,
184 m_groundDescendingGain,
185 m_footPlantedGain,
186 m_footRaisedGain,
187 m_footUnlockGain,
188 m_worldFromModelFeedbackGain,
189 m_errorUpDownBias,
190 m_alignWorldFromModelGain,
191 m_hipOrientationGain,
192 m_maxKneeAngleDifference,
193 m_ankleOrientationGain,
194 __ignore,
195 }
196 struct __FieldVisitor;
197 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
198 type Value = __Field;
199 fn expecting(
200 &self,
201 __formatter: &mut core::fmt::Formatter,
202 ) -> core::fmt::Result {
203 core::fmt::Formatter::write_str(__formatter, "field identifier")
204 }
205 #[allow(clippy::match_single_binding)]
207 #[allow(clippy::reversed_empty_ranges)]
208 #[allow(clippy::single_match)]
209 fn visit_key<__E>(
210 self,
211 __value: &str,
212 ) -> core::result::Result<Self::Value, __E>
213 where
214 __E: _serde::de::Error,
215 {
216 match __value {
217 "onOffGain" => Ok(__Field::m_onOffGain),
218 "groundAscendingGain" => Ok(__Field::m_groundAscendingGain),
219 "groundDescendingGain" => Ok(__Field::m_groundDescendingGain),
220 "footPlantedGain" => Ok(__Field::m_footPlantedGain),
221 "footRaisedGain" => Ok(__Field::m_footRaisedGain),
222 "footUnlockGain" => Ok(__Field::m_footUnlockGain),
223 "worldFromModelFeedbackGain" => {
224 Ok(__Field::m_worldFromModelFeedbackGain)
225 }
226 "errorUpDownBias" => Ok(__Field::m_errorUpDownBias),
227 "alignWorldFromModelGain" => {
228 Ok(__Field::m_alignWorldFromModelGain)
229 }
230 "hipOrientationGain" => Ok(__Field::m_hipOrientationGain),
231 "maxKneeAngleDifference" => Ok(__Field::m_maxKneeAngleDifference),
232 "ankleOrientationGain" => Ok(__Field::m_ankleOrientationGain),
233 _ => Ok(__Field::__ignore),
234 }
235 }
236 }
237 impl<'de> _serde::Deserialize<'de> for __Field {
238 #[inline]
239 fn deserialize<__D>(
240 __deserializer: __D,
241 ) -> core::result::Result<Self, __D::Error>
242 where
243 __D: _serde::Deserializer<'de>,
244 {
245 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
246 }
247 }
248 struct __hkbFootIkGainsVisitor<'de> {
249 marker: _serde::__private::PhantomData<hkbFootIkGains>,
250 lifetime: _serde::__private::PhantomData<&'de ()>,
251 }
252 #[allow(clippy::match_single_binding)]
253 #[allow(clippy::reversed_empty_ranges)]
254 #[allow(clippy::single_match)]
255 impl<'de> _serde::de::Visitor<'de> for __hkbFootIkGainsVisitor<'de> {
256 type Value = hkbFootIkGains;
257 fn expecting(
258 &self,
259 __formatter: &mut core::fmt::Formatter,
260 ) -> core::fmt::Result {
261 core::fmt::Formatter::write_str(__formatter, "struct hkbFootIkGains")
262 }
263 fn visit_struct_for_bytes<__A>(
264 self,
265 mut __map: __A,
266 ) -> _serde::__private::Result<Self::Value, __A::Error>
267 where
268 __A: _serde::de::MapAccess<'de>,
269 {
270 let __ptr = __A::class_ptr(&mut __map);
271 let mut m_onOffGain: _serde::__private::Option<f32> = _serde::__private::None;
272 let mut m_groundAscendingGain: _serde::__private::Option<f32> = _serde::__private::None;
273 let mut m_groundDescendingGain: _serde::__private::Option<f32> = _serde::__private::None;
274 let mut m_footPlantedGain: _serde::__private::Option<f32> = _serde::__private::None;
275 let mut m_footRaisedGain: _serde::__private::Option<f32> = _serde::__private::None;
276 let mut m_footUnlockGain: _serde::__private::Option<f32> = _serde::__private::None;
277 let mut m_worldFromModelFeedbackGain: _serde::__private::Option<
278 f32,
279 > = _serde::__private::None;
280 let mut m_errorUpDownBias: _serde::__private::Option<f32> = _serde::__private::None;
281 let mut m_alignWorldFromModelGain: _serde::__private::Option<f32> = _serde::__private::None;
282 let mut m_hipOrientationGain: _serde::__private::Option<f32> = _serde::__private::None;
283 let mut m_maxKneeAngleDifference: _serde::__private::Option<f32> = _serde::__private::None;
284 let mut m_ankleOrientationGain: _serde::__private::Option<f32> = _serde::__private::None;
285 for i in 0..12usize {
286 match i {
287 0usize => {
288 if _serde::__private::Option::is_some(&m_onOffGain) {
289 return _serde::__private::Err(
290 <__A::Error as _serde::de::Error>::duplicate_field(
291 "onOffGain",
292 ),
293 );
294 }
295 m_onOffGain = _serde::__private::Some(
296 match __A::next_value::<f32>(&mut __map) {
297 _serde::__private::Ok(__val) => __val,
298 _serde::__private::Err(__err) => {
299 return _serde::__private::Err(__err);
300 }
301 },
302 );
303 }
304 1usize => {
305 if _serde::__private::Option::is_some(
306 &m_groundAscendingGain,
307 ) {
308 return _serde::__private::Err(
309 <__A::Error as _serde::de::Error>::duplicate_field(
310 "groundAscendingGain",
311 ),
312 );
313 }
314 m_groundAscendingGain = _serde::__private::Some(
315 match __A::next_value::<f32>(&mut __map) {
316 _serde::__private::Ok(__val) => __val,
317 _serde::__private::Err(__err) => {
318 return _serde::__private::Err(__err);
319 }
320 },
321 );
322 }
323 2usize => {
324 if _serde::__private::Option::is_some(
325 &m_groundDescendingGain,
326 ) {
327 return _serde::__private::Err(
328 <__A::Error as _serde::de::Error>::duplicate_field(
329 "groundDescendingGain",
330 ),
331 );
332 }
333 m_groundDescendingGain = _serde::__private::Some(
334 match __A::next_value::<f32>(&mut __map) {
335 _serde::__private::Ok(__val) => __val,
336 _serde::__private::Err(__err) => {
337 return _serde::__private::Err(__err);
338 }
339 },
340 );
341 }
342 3usize => {
343 if _serde::__private::Option::is_some(&m_footPlantedGain) {
344 return _serde::__private::Err(
345 <__A::Error as _serde::de::Error>::duplicate_field(
346 "footPlantedGain",
347 ),
348 );
349 }
350 m_footPlantedGain = _serde::__private::Some(
351 match __A::next_value::<f32>(&mut __map) {
352 _serde::__private::Ok(__val) => __val,
353 _serde::__private::Err(__err) => {
354 return _serde::__private::Err(__err);
355 }
356 },
357 );
358 }
359 4usize => {
360 if _serde::__private::Option::is_some(&m_footRaisedGain) {
361 return _serde::__private::Err(
362 <__A::Error as _serde::de::Error>::duplicate_field(
363 "footRaisedGain",
364 ),
365 );
366 }
367 m_footRaisedGain = _serde::__private::Some(
368 match __A::next_value::<f32>(&mut __map) {
369 _serde::__private::Ok(__val) => __val,
370 _serde::__private::Err(__err) => {
371 return _serde::__private::Err(__err);
372 }
373 },
374 );
375 }
376 5usize => {
377 if _serde::__private::Option::is_some(&m_footUnlockGain) {
378 return _serde::__private::Err(
379 <__A::Error as _serde::de::Error>::duplicate_field(
380 "footUnlockGain",
381 ),
382 );
383 }
384 m_footUnlockGain = _serde::__private::Some(
385 match __A::next_value::<f32>(&mut __map) {
386 _serde::__private::Ok(__val) => __val,
387 _serde::__private::Err(__err) => {
388 return _serde::__private::Err(__err);
389 }
390 },
391 );
392 }
393 6usize => {
394 if _serde::__private::Option::is_some(
395 &m_worldFromModelFeedbackGain,
396 ) {
397 return _serde::__private::Err(
398 <__A::Error as _serde::de::Error>::duplicate_field(
399 "worldFromModelFeedbackGain",
400 ),
401 );
402 }
403 m_worldFromModelFeedbackGain = _serde::__private::Some(
404 match __A::next_value::<f32>(&mut __map) {
405 _serde::__private::Ok(__val) => __val,
406 _serde::__private::Err(__err) => {
407 return _serde::__private::Err(__err);
408 }
409 },
410 );
411 }
412 7usize => {
413 if _serde::__private::Option::is_some(&m_errorUpDownBias) {
414 return _serde::__private::Err(
415 <__A::Error as _serde::de::Error>::duplicate_field(
416 "errorUpDownBias",
417 ),
418 );
419 }
420 m_errorUpDownBias = _serde::__private::Some(
421 match __A::next_value::<f32>(&mut __map) {
422 _serde::__private::Ok(__val) => __val,
423 _serde::__private::Err(__err) => {
424 return _serde::__private::Err(__err);
425 }
426 },
427 );
428 }
429 8usize => {
430 if _serde::__private::Option::is_some(
431 &m_alignWorldFromModelGain,
432 ) {
433 return _serde::__private::Err(
434 <__A::Error as _serde::de::Error>::duplicate_field(
435 "alignWorldFromModelGain",
436 ),
437 );
438 }
439 m_alignWorldFromModelGain = _serde::__private::Some(
440 match __A::next_value::<f32>(&mut __map) {
441 _serde::__private::Ok(__val) => __val,
442 _serde::__private::Err(__err) => {
443 return _serde::__private::Err(__err);
444 }
445 },
446 );
447 }
448 9usize => {
449 if _serde::__private::Option::is_some(
450 &m_hipOrientationGain,
451 ) {
452 return _serde::__private::Err(
453 <__A::Error as _serde::de::Error>::duplicate_field(
454 "hipOrientationGain",
455 ),
456 );
457 }
458 m_hipOrientationGain = _serde::__private::Some(
459 match __A::next_value::<f32>(&mut __map) {
460 _serde::__private::Ok(__val) => __val,
461 _serde::__private::Err(__err) => {
462 return _serde::__private::Err(__err);
463 }
464 },
465 );
466 }
467 10usize => {
468 if _serde::__private::Option::is_some(
469 &m_maxKneeAngleDifference,
470 ) {
471 return _serde::__private::Err(
472 <__A::Error as _serde::de::Error>::duplicate_field(
473 "maxKneeAngleDifference",
474 ),
475 );
476 }
477 m_maxKneeAngleDifference = _serde::__private::Some(
478 match __A::next_value::<f32>(&mut __map) {
479 _serde::__private::Ok(__val) => __val,
480 _serde::__private::Err(__err) => {
481 return _serde::__private::Err(__err);
482 }
483 },
484 );
485 }
486 11usize => {
487 if _serde::__private::Option::is_some(
488 &m_ankleOrientationGain,
489 ) {
490 return _serde::__private::Err(
491 <__A::Error as _serde::de::Error>::duplicate_field(
492 "ankleOrientationGain",
493 ),
494 );
495 }
496 m_ankleOrientationGain = _serde::__private::Some(
497 match __A::next_value::<f32>(&mut __map) {
498 _serde::__private::Ok(__val) => __val,
499 _serde::__private::Err(__err) => {
500 return _serde::__private::Err(__err);
501 }
502 },
503 );
504 }
505 _ => {}
506 }
507 }
508 let m_onOffGain = match m_onOffGain {
509 _serde::__private::Some(__field) => __field,
510 _serde::__private::None => {
511 return _serde::__private::Err(
512 <__A::Error as _serde::de::Error>::missing_field(
513 "onOffGain",
514 ),
515 );
516 }
517 };
518 let m_groundAscendingGain = match m_groundAscendingGain {
519 _serde::__private::Some(__field) => __field,
520 _serde::__private::None => {
521 return _serde::__private::Err(
522 <__A::Error as _serde::de::Error>::missing_field(
523 "groundAscendingGain",
524 ),
525 );
526 }
527 };
528 let m_groundDescendingGain = match m_groundDescendingGain {
529 _serde::__private::Some(__field) => __field,
530 _serde::__private::None => {
531 return _serde::__private::Err(
532 <__A::Error as _serde::de::Error>::missing_field(
533 "groundDescendingGain",
534 ),
535 );
536 }
537 };
538 let m_footPlantedGain = match m_footPlantedGain {
539 _serde::__private::Some(__field) => __field,
540 _serde::__private::None => {
541 return _serde::__private::Err(
542 <__A::Error as _serde::de::Error>::missing_field(
543 "footPlantedGain",
544 ),
545 );
546 }
547 };
548 let m_footRaisedGain = match m_footRaisedGain {
549 _serde::__private::Some(__field) => __field,
550 _serde::__private::None => {
551 return _serde::__private::Err(
552 <__A::Error as _serde::de::Error>::missing_field(
553 "footRaisedGain",
554 ),
555 );
556 }
557 };
558 let m_footUnlockGain = match m_footUnlockGain {
559 _serde::__private::Some(__field) => __field,
560 _serde::__private::None => {
561 return _serde::__private::Err(
562 <__A::Error as _serde::de::Error>::missing_field(
563 "footUnlockGain",
564 ),
565 );
566 }
567 };
568 let m_worldFromModelFeedbackGain = match m_worldFromModelFeedbackGain {
569 _serde::__private::Some(__field) => __field,
570 _serde::__private::None => {
571 return _serde::__private::Err(
572 <__A::Error as _serde::de::Error>::missing_field(
573 "worldFromModelFeedbackGain",
574 ),
575 );
576 }
577 };
578 let m_errorUpDownBias = match m_errorUpDownBias {
579 _serde::__private::Some(__field) => __field,
580 _serde::__private::None => {
581 return _serde::__private::Err(
582 <__A::Error as _serde::de::Error>::missing_field(
583 "errorUpDownBias",
584 ),
585 );
586 }
587 };
588 let m_alignWorldFromModelGain = match m_alignWorldFromModelGain {
589 _serde::__private::Some(__field) => __field,
590 _serde::__private::None => {
591 return _serde::__private::Err(
592 <__A::Error as _serde::de::Error>::missing_field(
593 "alignWorldFromModelGain",
594 ),
595 );
596 }
597 };
598 let m_hipOrientationGain = match m_hipOrientationGain {
599 _serde::__private::Some(__field) => __field,
600 _serde::__private::None => {
601 return _serde::__private::Err(
602 <__A::Error as _serde::de::Error>::missing_field(
603 "hipOrientationGain",
604 ),
605 );
606 }
607 };
608 let m_maxKneeAngleDifference = match m_maxKneeAngleDifference {
609 _serde::__private::Some(__field) => __field,
610 _serde::__private::None => {
611 return _serde::__private::Err(
612 <__A::Error as _serde::de::Error>::missing_field(
613 "maxKneeAngleDifference",
614 ),
615 );
616 }
617 };
618 let m_ankleOrientationGain = match m_ankleOrientationGain {
619 _serde::__private::Some(__field) => __field,
620 _serde::__private::None => {
621 return _serde::__private::Err(
622 <__A::Error as _serde::de::Error>::missing_field(
623 "ankleOrientationGain",
624 ),
625 );
626 }
627 };
628 _serde::__private::Ok(hkbFootIkGains {
629 __ptr,
630 m_onOffGain,
631 m_groundAscendingGain,
632 m_groundDescendingGain,
633 m_footPlantedGain,
634 m_footRaisedGain,
635 m_footUnlockGain,
636 m_worldFromModelFeedbackGain,
637 m_errorUpDownBias,
638 m_alignWorldFromModelGain,
639 m_hipOrientationGain,
640 m_maxKneeAngleDifference,
641 m_ankleOrientationGain,
642 })
643 }
644 #[allow(clippy::manual_unwrap_or_default)]
645 fn visit_struct<__A>(
646 self,
647 mut __map: __A,
648 ) -> _serde::__private::Result<Self::Value, __A::Error>
649 where
650 __A: _serde::de::MapAccess<'de>,
651 {
652 let mut m_onOffGain: _serde::__private::Option<f32> = _serde::__private::None;
653 let mut m_groundAscendingGain: _serde::__private::Option<f32> = _serde::__private::None;
654 let mut m_groundDescendingGain: _serde::__private::Option<f32> = _serde::__private::None;
655 let mut m_footPlantedGain: _serde::__private::Option<f32> = _serde::__private::None;
656 let mut m_footRaisedGain: _serde::__private::Option<f32> = _serde::__private::None;
657 let mut m_footUnlockGain: _serde::__private::Option<f32> = _serde::__private::None;
658 let mut m_worldFromModelFeedbackGain: _serde::__private::Option<
659 f32,
660 > = _serde::__private::None;
661 let mut m_errorUpDownBias: _serde::__private::Option<f32> = _serde::__private::None;
662 let mut m_alignWorldFromModelGain: _serde::__private::Option<f32> = _serde::__private::None;
663 let mut m_hipOrientationGain: _serde::__private::Option<f32> = _serde::__private::None;
664 let mut m_maxKneeAngleDifference: _serde::__private::Option<f32> = _serde::__private::None;
665 let mut m_ankleOrientationGain: _serde::__private::Option<f32> = _serde::__private::None;
666 while let _serde::__private::Some(__key) = {
667 __A::next_key::<__Field>(&mut __map)?
668 } {
669 match __key {
670 __Field::m_onOffGain => {
671 #[cfg(
672 any(feature = "strict", feature = "ignore_duplicates")
673 )]
674 if _serde::__private::Option::is_some(&m_onOffGain) {
675 #[cfg(feature = "ignore_duplicates")]
676 {
677 __A::skip_value(&mut __map)?;
678 continue;
679 }
680 #[cfg(feature = "strict")]
681 return _serde::__private::Err(
682 <__A::Error as _serde::de::Error>::duplicate_field(
683 "onOffGain",
684 ),
685 );
686 }
687 m_onOffGain = _serde::__private::Some(
688 match __A::next_value::<f32>(&mut __map) {
689 _serde::__private::Ok(__val) => __val,
690 _serde::__private::Err(__err) => {
691 return _serde::__private::Err(__err);
692 }
693 },
694 );
695 }
696 __Field::m_groundAscendingGain => {
697 #[cfg(
698 any(feature = "strict", feature = "ignore_duplicates")
699 )]
700 if _serde::__private::Option::is_some(
701 &m_groundAscendingGain,
702 ) {
703 #[cfg(feature = "ignore_duplicates")]
704 {
705 __A::skip_value(&mut __map)?;
706 continue;
707 }
708 #[cfg(feature = "strict")]
709 return _serde::__private::Err(
710 <__A::Error as _serde::de::Error>::duplicate_field(
711 "groundAscendingGain",
712 ),
713 );
714 }
715 m_groundAscendingGain = _serde::__private::Some(
716 match __A::next_value::<f32>(&mut __map) {
717 _serde::__private::Ok(__val) => __val,
718 _serde::__private::Err(__err) => {
719 return _serde::__private::Err(__err);
720 }
721 },
722 );
723 }
724 __Field::m_groundDescendingGain => {
725 #[cfg(
726 any(feature = "strict", feature = "ignore_duplicates")
727 )]
728 if _serde::__private::Option::is_some(
729 &m_groundDescendingGain,
730 ) {
731 #[cfg(feature = "ignore_duplicates")]
732 {
733 __A::skip_value(&mut __map)?;
734 continue;
735 }
736 #[cfg(feature = "strict")]
737 return _serde::__private::Err(
738 <__A::Error as _serde::de::Error>::duplicate_field(
739 "groundDescendingGain",
740 ),
741 );
742 }
743 m_groundDescendingGain = _serde::__private::Some(
744 match __A::next_value::<f32>(&mut __map) {
745 _serde::__private::Ok(__val) => __val,
746 _serde::__private::Err(__err) => {
747 return _serde::__private::Err(__err);
748 }
749 },
750 );
751 }
752 __Field::m_footPlantedGain => {
753 #[cfg(
754 any(feature = "strict", feature = "ignore_duplicates")
755 )]
756 if _serde::__private::Option::is_some(&m_footPlantedGain) {
757 #[cfg(feature = "ignore_duplicates")]
758 {
759 __A::skip_value(&mut __map)?;
760 continue;
761 }
762 #[cfg(feature = "strict")]
763 return _serde::__private::Err(
764 <__A::Error as _serde::de::Error>::duplicate_field(
765 "footPlantedGain",
766 ),
767 );
768 }
769 m_footPlantedGain = _serde::__private::Some(
770 match __A::next_value::<f32>(&mut __map) {
771 _serde::__private::Ok(__val) => __val,
772 _serde::__private::Err(__err) => {
773 return _serde::__private::Err(__err);
774 }
775 },
776 );
777 }
778 __Field::m_footRaisedGain => {
779 #[cfg(
780 any(feature = "strict", feature = "ignore_duplicates")
781 )]
782 if _serde::__private::Option::is_some(&m_footRaisedGain) {
783 #[cfg(feature = "ignore_duplicates")]
784 {
785 __A::skip_value(&mut __map)?;
786 continue;
787 }
788 #[cfg(feature = "strict")]
789 return _serde::__private::Err(
790 <__A::Error as _serde::de::Error>::duplicate_field(
791 "footRaisedGain",
792 ),
793 );
794 }
795 m_footRaisedGain = _serde::__private::Some(
796 match __A::next_value::<f32>(&mut __map) {
797 _serde::__private::Ok(__val) => __val,
798 _serde::__private::Err(__err) => {
799 return _serde::__private::Err(__err);
800 }
801 },
802 );
803 }
804 __Field::m_footUnlockGain => {
805 #[cfg(
806 any(feature = "strict", feature = "ignore_duplicates")
807 )]
808 if _serde::__private::Option::is_some(&m_footUnlockGain) {
809 #[cfg(feature = "ignore_duplicates")]
810 {
811 __A::skip_value(&mut __map)?;
812 continue;
813 }
814 #[cfg(feature = "strict")]
815 return _serde::__private::Err(
816 <__A::Error as _serde::de::Error>::duplicate_field(
817 "footUnlockGain",
818 ),
819 );
820 }
821 m_footUnlockGain = _serde::__private::Some(
822 match __A::next_value::<f32>(&mut __map) {
823 _serde::__private::Ok(__val) => __val,
824 _serde::__private::Err(__err) => {
825 return _serde::__private::Err(__err);
826 }
827 },
828 );
829 }
830 __Field::m_worldFromModelFeedbackGain => {
831 #[cfg(
832 any(feature = "strict", feature = "ignore_duplicates")
833 )]
834 if _serde::__private::Option::is_some(
835 &m_worldFromModelFeedbackGain,
836 ) {
837 #[cfg(feature = "ignore_duplicates")]
838 {
839 __A::skip_value(&mut __map)?;
840 continue;
841 }
842 #[cfg(feature = "strict")]
843 return _serde::__private::Err(
844 <__A::Error as _serde::de::Error>::duplicate_field(
845 "worldFromModelFeedbackGain",
846 ),
847 );
848 }
849 m_worldFromModelFeedbackGain = _serde::__private::Some(
850 match __A::next_value::<f32>(&mut __map) {
851 _serde::__private::Ok(__val) => __val,
852 _serde::__private::Err(__err) => {
853 return _serde::__private::Err(__err);
854 }
855 },
856 );
857 }
858 __Field::m_errorUpDownBias => {
859 #[cfg(
860 any(feature = "strict", feature = "ignore_duplicates")
861 )]
862 if _serde::__private::Option::is_some(&m_errorUpDownBias) {
863 #[cfg(feature = "ignore_duplicates")]
864 {
865 __A::skip_value(&mut __map)?;
866 continue;
867 }
868 #[cfg(feature = "strict")]
869 return _serde::__private::Err(
870 <__A::Error as _serde::de::Error>::duplicate_field(
871 "errorUpDownBias",
872 ),
873 );
874 }
875 m_errorUpDownBias = _serde::__private::Some(
876 match __A::next_value::<f32>(&mut __map) {
877 _serde::__private::Ok(__val) => __val,
878 _serde::__private::Err(__err) => {
879 return _serde::__private::Err(__err);
880 }
881 },
882 );
883 }
884 __Field::m_alignWorldFromModelGain => {
885 #[cfg(
886 any(feature = "strict", feature = "ignore_duplicates")
887 )]
888 if _serde::__private::Option::is_some(
889 &m_alignWorldFromModelGain,
890 ) {
891 #[cfg(feature = "ignore_duplicates")]
892 {
893 __A::skip_value(&mut __map)?;
894 continue;
895 }
896 #[cfg(feature = "strict")]
897 return _serde::__private::Err(
898 <__A::Error as _serde::de::Error>::duplicate_field(
899 "alignWorldFromModelGain",
900 ),
901 );
902 }
903 m_alignWorldFromModelGain = _serde::__private::Some(
904 match __A::next_value::<f32>(&mut __map) {
905 _serde::__private::Ok(__val) => __val,
906 _serde::__private::Err(__err) => {
907 return _serde::__private::Err(__err);
908 }
909 },
910 );
911 }
912 __Field::m_hipOrientationGain => {
913 #[cfg(
914 any(feature = "strict", feature = "ignore_duplicates")
915 )]
916 if _serde::__private::Option::is_some(
917 &m_hipOrientationGain,
918 ) {
919 #[cfg(feature = "ignore_duplicates")]
920 {
921 __A::skip_value(&mut __map)?;
922 continue;
923 }
924 #[cfg(feature = "strict")]
925 return _serde::__private::Err(
926 <__A::Error as _serde::de::Error>::duplicate_field(
927 "hipOrientationGain",
928 ),
929 );
930 }
931 m_hipOrientationGain = _serde::__private::Some(
932 match __A::next_value::<f32>(&mut __map) {
933 _serde::__private::Ok(__val) => __val,
934 _serde::__private::Err(__err) => {
935 return _serde::__private::Err(__err);
936 }
937 },
938 );
939 }
940 __Field::m_maxKneeAngleDifference => {
941 #[cfg(
942 any(feature = "strict", feature = "ignore_duplicates")
943 )]
944 if _serde::__private::Option::is_some(
945 &m_maxKneeAngleDifference,
946 ) {
947 #[cfg(feature = "ignore_duplicates")]
948 {
949 __A::skip_value(&mut __map)?;
950 continue;
951 }
952 #[cfg(feature = "strict")]
953 return _serde::__private::Err(
954 <__A::Error as _serde::de::Error>::duplicate_field(
955 "maxKneeAngleDifference",
956 ),
957 );
958 }
959 m_maxKneeAngleDifference = _serde::__private::Some(
960 match __A::next_value::<f32>(&mut __map) {
961 _serde::__private::Ok(__val) => __val,
962 _serde::__private::Err(__err) => {
963 return _serde::__private::Err(__err);
964 }
965 },
966 );
967 }
968 __Field::m_ankleOrientationGain => {
969 #[cfg(
970 any(feature = "strict", feature = "ignore_duplicates")
971 )]
972 if _serde::__private::Option::is_some(
973 &m_ankleOrientationGain,
974 ) {
975 #[cfg(feature = "ignore_duplicates")]
976 {
977 __A::skip_value(&mut __map)?;
978 continue;
979 }
980 #[cfg(feature = "strict")]
981 return _serde::__private::Err(
982 <__A::Error as _serde::de::Error>::duplicate_field(
983 "ankleOrientationGain",
984 ),
985 );
986 }
987 m_ankleOrientationGain = _serde::__private::Some(
988 match __A::next_value::<f32>(&mut __map) {
989 _serde::__private::Ok(__val) => __val,
990 _serde::__private::Err(__err) => {
991 return _serde::__private::Err(__err);
992 }
993 },
994 );
995 }
996 _ => __A::skip_value(&mut __map)?,
997 }
998 }
999 let m_onOffGain = match m_onOffGain {
1000 _serde::__private::Some(__field) => __field,
1001 _serde::__private::None => {
1002 #[cfg(feature = "strict")]
1003 return _serde::__private::Err(
1004 <__A::Error as _serde::de::Error>::missing_field(
1005 "onOffGain",
1006 ),
1007 );
1008 #[cfg(not(feature = "strict"))] Default::default()
1009 }
1010 };
1011 let m_groundAscendingGain = match m_groundAscendingGain {
1012 _serde::__private::Some(__field) => __field,
1013 _serde::__private::None => {
1014 #[cfg(feature = "strict")]
1015 return _serde::__private::Err(
1016 <__A::Error as _serde::de::Error>::missing_field(
1017 "groundAscendingGain",
1018 ),
1019 );
1020 #[cfg(not(feature = "strict"))] Default::default()
1021 }
1022 };
1023 let m_groundDescendingGain = match m_groundDescendingGain {
1024 _serde::__private::Some(__field) => __field,
1025 _serde::__private::None => {
1026 #[cfg(feature = "strict")]
1027 return _serde::__private::Err(
1028 <__A::Error as _serde::de::Error>::missing_field(
1029 "groundDescendingGain",
1030 ),
1031 );
1032 #[cfg(not(feature = "strict"))] Default::default()
1033 }
1034 };
1035 let m_footPlantedGain = match m_footPlantedGain {
1036 _serde::__private::Some(__field) => __field,
1037 _serde::__private::None => {
1038 #[cfg(feature = "strict")]
1039 return _serde::__private::Err(
1040 <__A::Error as _serde::de::Error>::missing_field(
1041 "footPlantedGain",
1042 ),
1043 );
1044 #[cfg(not(feature = "strict"))] Default::default()
1045 }
1046 };
1047 let m_footRaisedGain = match m_footRaisedGain {
1048 _serde::__private::Some(__field) => __field,
1049 _serde::__private::None => {
1050 #[cfg(feature = "strict")]
1051 return _serde::__private::Err(
1052 <__A::Error as _serde::de::Error>::missing_field(
1053 "footRaisedGain",
1054 ),
1055 );
1056 #[cfg(not(feature = "strict"))] Default::default()
1057 }
1058 };
1059 let m_footUnlockGain = match m_footUnlockGain {
1060 _serde::__private::Some(__field) => __field,
1061 _serde::__private::None => {
1062 #[cfg(feature = "strict")]
1063 return _serde::__private::Err(
1064 <__A::Error as _serde::de::Error>::missing_field(
1065 "footUnlockGain",
1066 ),
1067 );
1068 #[cfg(not(feature = "strict"))] Default::default()
1069 }
1070 };
1071 let m_worldFromModelFeedbackGain = match m_worldFromModelFeedbackGain {
1072 _serde::__private::Some(__field) => __field,
1073 _serde::__private::None => {
1074 #[cfg(feature = "strict")]
1075 return _serde::__private::Err(
1076 <__A::Error as _serde::de::Error>::missing_field(
1077 "worldFromModelFeedbackGain",
1078 ),
1079 );
1080 #[cfg(not(feature = "strict"))] Default::default()
1081 }
1082 };
1083 let m_errorUpDownBias = match m_errorUpDownBias {
1084 _serde::__private::Some(__field) => __field,
1085 _serde::__private::None => {
1086 #[cfg(feature = "strict")]
1087 return _serde::__private::Err(
1088 <__A::Error as _serde::de::Error>::missing_field(
1089 "errorUpDownBias",
1090 ),
1091 );
1092 #[cfg(not(feature = "strict"))] Default::default()
1093 }
1094 };
1095 let m_alignWorldFromModelGain = match m_alignWorldFromModelGain {
1096 _serde::__private::Some(__field) => __field,
1097 _serde::__private::None => {
1098 #[cfg(feature = "strict")]
1099 return _serde::__private::Err(
1100 <__A::Error as _serde::de::Error>::missing_field(
1101 "alignWorldFromModelGain",
1102 ),
1103 );
1104 #[cfg(not(feature = "strict"))] Default::default()
1105 }
1106 };
1107 let m_hipOrientationGain = match m_hipOrientationGain {
1108 _serde::__private::Some(__field) => __field,
1109 _serde::__private::None => {
1110 #[cfg(feature = "strict")]
1111 return _serde::__private::Err(
1112 <__A::Error as _serde::de::Error>::missing_field(
1113 "hipOrientationGain",
1114 ),
1115 );
1116 #[cfg(not(feature = "strict"))] Default::default()
1117 }
1118 };
1119 let m_maxKneeAngleDifference = match m_maxKneeAngleDifference {
1120 _serde::__private::Some(__field) => __field,
1121 _serde::__private::None => {
1122 #[cfg(feature = "strict")]
1123 return _serde::__private::Err(
1124 <__A::Error as _serde::de::Error>::missing_field(
1125 "maxKneeAngleDifference",
1126 ),
1127 );
1128 #[cfg(not(feature = "strict"))] Default::default()
1129 }
1130 };
1131 let m_ankleOrientationGain = match m_ankleOrientationGain {
1132 _serde::__private::Some(__field) => __field,
1133 _serde::__private::None => {
1134 #[cfg(feature = "strict")]
1135 return _serde::__private::Err(
1136 <__A::Error as _serde::de::Error>::missing_field(
1137 "ankleOrientationGain",
1138 ),
1139 );
1140 #[cfg(not(feature = "strict"))] Default::default()
1141 }
1142 };
1143 let __ptr = __A::class_ptr(&mut __map);
1144 _serde::__private::Ok(hkbFootIkGains {
1145 __ptr,
1146 m_onOffGain,
1147 m_groundAscendingGain,
1148 m_groundDescendingGain,
1149 m_footPlantedGain,
1150 m_footRaisedGain,
1151 m_footUnlockGain,
1152 m_worldFromModelFeedbackGain,
1153 m_errorUpDownBias,
1154 m_alignWorldFromModelGain,
1155 m_hipOrientationGain,
1156 m_maxKneeAngleDifference,
1157 m_ankleOrientationGain,
1158 })
1159 }
1160 }
1161 const FIELDS: &[&str] = &[
1162 "onOffGain",
1163 "groundAscendingGain",
1164 "groundDescendingGain",
1165 "footPlantedGain",
1166 "footRaisedGain",
1167 "footUnlockGain",
1168 "worldFromModelFeedbackGain",
1169 "errorUpDownBias",
1170 "alignWorldFromModelGain",
1171 "hipOrientationGain",
1172 "maxKneeAngleDifference",
1173 "ankleOrientationGain",
1174 ];
1175 _serde::Deserializer::deserialize_struct(
1176 deserializer,
1177 "hkbFootIkGains",
1178 FIELDS,
1179 __hkbFootIkGainsVisitor {
1180 marker: _serde::__private::PhantomData::<hkbFootIkGains>,
1181 lifetime: _serde::__private::PhantomData,
1182 },
1183 )
1184 }
1185 }
1186};