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 hkbFootIkModifierLeg {
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 = "originalAnkleTransformMS"))]
31 #[cfg_attr(feature = "serde", serde(rename = "originalAnkleTransformMS"))]
32 pub m_originalAnkleTransformMS: QsTransform,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "prevAnkleRotLS"))]
39 #[cfg_attr(feature = "serde", serde(rename = "prevAnkleRotLS"))]
40 pub m_prevAnkleRotLS: Quaternion,
41 #[cfg_attr(feature = "json_schema", schemars(rename = "kneeAxisLS"))]
46 #[cfg_attr(feature = "serde", serde(rename = "kneeAxisLS"))]
47 pub m_kneeAxisLS: Vector4,
48 #[cfg_attr(feature = "json_schema", schemars(rename = "footEndLS"))]
53 #[cfg_attr(feature = "serde", serde(rename = "footEndLS"))]
54 pub m_footEndLS: Vector4,
55 #[cfg_attr(feature = "json_schema", schemars(rename = "ungroundedEvent"))]
60 #[cfg_attr(feature = "serde", serde(rename = "ungroundedEvent"))]
61 pub m_ungroundedEvent: hkbEventProperty,
62 #[cfg_attr(feature = "json_schema", schemars(rename = "footPlantedAnkleHeightMS"))]
67 #[cfg_attr(feature = "serde", serde(rename = "footPlantedAnkleHeightMS"))]
68 pub m_footPlantedAnkleHeightMS: f32,
69 #[cfg_attr(feature = "json_schema", schemars(rename = "footRaisedAnkleHeightMS"))]
74 #[cfg_attr(feature = "serde", serde(rename = "footRaisedAnkleHeightMS"))]
75 pub m_footRaisedAnkleHeightMS: f32,
76 #[cfg_attr(feature = "json_schema", schemars(rename = "maxAnkleHeightMS"))]
81 #[cfg_attr(feature = "serde", serde(rename = "maxAnkleHeightMS"))]
82 pub m_maxAnkleHeightMS: f32,
83 #[cfg_attr(feature = "json_schema", schemars(rename = "minAnkleHeightMS"))]
88 #[cfg_attr(feature = "serde", serde(rename = "minAnkleHeightMS"))]
89 pub m_minAnkleHeightMS: f32,
90 #[cfg_attr(feature = "json_schema", schemars(rename = "maxKneeAngleDegrees"))]
95 #[cfg_attr(feature = "serde", serde(rename = "maxKneeAngleDegrees"))]
96 pub m_maxKneeAngleDegrees: f32,
97 #[cfg_attr(feature = "json_schema", schemars(rename = "minKneeAngleDegrees"))]
102 #[cfg_attr(feature = "serde", serde(rename = "minKneeAngleDegrees"))]
103 pub m_minKneeAngleDegrees: f32,
104 #[cfg_attr(feature = "json_schema", schemars(rename = "verticalError"))]
109 #[cfg_attr(feature = "serde", serde(rename = "verticalError"))]
110 pub m_verticalError: f32,
111 #[cfg_attr(feature = "json_schema", schemars(rename = "maxAnkleAngleDegrees"))]
116 #[cfg_attr(feature = "serde", serde(rename = "maxAnkleAngleDegrees"))]
117 pub m_maxAnkleAngleDegrees: f32,
118 #[cfg_attr(feature = "json_schema", schemars(rename = "hipIndex"))]
123 #[cfg_attr(feature = "serde", serde(rename = "hipIndex"))]
124 pub m_hipIndex: i16,
125 #[cfg_attr(feature = "json_schema", schemars(rename = "kneeIndex"))]
130 #[cfg_attr(feature = "serde", serde(rename = "kneeIndex"))]
131 pub m_kneeIndex: i16,
132 #[cfg_attr(feature = "json_schema", schemars(rename = "ankleIndex"))]
137 #[cfg_attr(feature = "serde", serde(rename = "ankleIndex"))]
138 pub m_ankleIndex: i16,
139 #[cfg_attr(feature = "json_schema", schemars(rename = "hitSomething"))]
144 #[cfg_attr(feature = "serde", serde(rename = "hitSomething"))]
145 pub m_hitSomething: bool,
146 #[cfg_attr(feature = "json_schema", schemars(rename = "isPlantedMS"))]
151 #[cfg_attr(feature = "serde", serde(rename = "isPlantedMS"))]
152 pub m_isPlantedMS: bool,
153 #[cfg_attr(
158 feature = "json_schema",
159 schemars(rename = "isOriginalAnkleTransformMSSet")
160 )]
161 #[cfg_attr(feature = "serde", serde(rename = "isOriginalAnkleTransformMSSet"))]
162 pub m_isOriginalAnkleTransformMSSet: bool,
163}
164const _: () = {
165 use havok_serde as _serde;
166 impl _serde::HavokClass for hkbFootIkModifierLeg {
167 #[inline]
168 fn name(&self) -> &'static str {
169 "hkbFootIkModifierLeg"
170 }
171 #[inline]
172 fn signature(&self) -> _serde::__private::Signature {
173 _serde::__private::Signature::new(0x9f3e3a04)
174 }
175 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
176 fn deps_indexes(&self) -> Vec<usize> {
177 let mut v = Vec::new();
178 v.extend(self.m_ungroundedEvent.deps_indexes());
179 v
180 }
181 }
182 impl _serde::Serialize for hkbFootIkModifierLeg {
183 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
184 where
185 S: _serde::ser::Serializer,
186 {
187 let class_meta = self
188 .__ptr
189 .map(|name| (name, _serde::__private::Signature::new(0x9f3e3a04)));
190 let mut serializer = __serializer
191 .serialize_struct("hkbFootIkModifierLeg", class_meta, (160u64, 160u64))?;
192 serializer
193 .serialize_field(
194 "originalAnkleTransformMS",
195 &self.m_originalAnkleTransformMS,
196 )?;
197 serializer.skip_field("prevAnkleRotLS", &self.m_prevAnkleRotLS)?;
198 serializer.serialize_field("kneeAxisLS", &self.m_kneeAxisLS)?;
199 serializer.serialize_field("footEndLS", &self.m_footEndLS)?;
200 serializer.serialize_field("ungroundedEvent", &self.m_ungroundedEvent)?;
201 serializer
202 .serialize_field(
203 "footPlantedAnkleHeightMS",
204 &self.m_footPlantedAnkleHeightMS,
205 )?;
206 serializer
207 .serialize_field(
208 "footRaisedAnkleHeightMS",
209 &self.m_footRaisedAnkleHeightMS,
210 )?;
211 serializer.serialize_field("maxAnkleHeightMS", &self.m_maxAnkleHeightMS)?;
212 serializer.serialize_field("minAnkleHeightMS", &self.m_minAnkleHeightMS)?;
213 serializer
214 .serialize_field("maxKneeAngleDegrees", &self.m_maxKneeAngleDegrees)?;
215 serializer
216 .serialize_field("minKneeAngleDegrees", &self.m_minKneeAngleDegrees)?;
217 serializer.serialize_field("verticalError", &self.m_verticalError)?;
218 serializer
219 .serialize_field("maxAnkleAngleDegrees", &self.m_maxAnkleAngleDegrees)?;
220 serializer.serialize_field("hipIndex", &self.m_hipIndex)?;
221 serializer.serialize_field("kneeIndex", &self.m_kneeIndex)?;
222 serializer.serialize_field("ankleIndex", &self.m_ankleIndex)?;
223 serializer.serialize_field("hitSomething", &self.m_hitSomething)?;
224 serializer.serialize_field("isPlantedMS", &self.m_isPlantedMS)?;
225 serializer
226 .serialize_field(
227 "isOriginalAnkleTransformMSSet",
228 &self.m_isOriginalAnkleTransformMSSet,
229 )?;
230 serializer.pad_field([0u8; 15usize].as_slice(), [0u8; 7usize].as_slice())?;
231 serializer.end()
232 }
233 }
234};
235#[doc(hidden)]
236#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
237const _: () = {
238 use havok_serde as _serde;
239 #[automatically_derived]
240 impl<'de> _serde::Deserialize<'de> for hkbFootIkModifierLeg {
241 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
242 where
243 __D: _serde::Deserializer<'de>,
244 {
245 #[allow(non_camel_case_types)]
246 enum __Field {
247 m_originalAnkleTransformMS,
248 m_kneeAxisLS,
249 m_footEndLS,
250 m_ungroundedEvent,
251 m_footPlantedAnkleHeightMS,
252 m_footRaisedAnkleHeightMS,
253 m_maxAnkleHeightMS,
254 m_minAnkleHeightMS,
255 m_maxKneeAngleDegrees,
256 m_minKneeAngleDegrees,
257 m_verticalError,
258 m_maxAnkleAngleDegrees,
259 m_hipIndex,
260 m_kneeIndex,
261 m_ankleIndex,
262 m_hitSomething,
263 m_isPlantedMS,
264 m_isOriginalAnkleTransformMSSet,
265 __ignore,
266 }
267 struct __FieldVisitor;
268 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
269 type Value = __Field;
270 fn expecting(
271 &self,
272 __formatter: &mut core::fmt::Formatter,
273 ) -> core::fmt::Result {
274 core::fmt::Formatter::write_str(__formatter, "field identifier")
275 }
276 #[allow(clippy::match_single_binding)]
278 #[allow(clippy::reversed_empty_ranges)]
279 #[allow(clippy::single_match)]
280 fn visit_key<__E>(
281 self,
282 __value: &str,
283 ) -> core::result::Result<Self::Value, __E>
284 where
285 __E: _serde::de::Error,
286 {
287 match __value {
288 "originalAnkleTransformMS" => {
289 Ok(__Field::m_originalAnkleTransformMS)
290 }
291 "kneeAxisLS" => Ok(__Field::m_kneeAxisLS),
292 "footEndLS" => Ok(__Field::m_footEndLS),
293 "ungroundedEvent" => Ok(__Field::m_ungroundedEvent),
294 "footPlantedAnkleHeightMS" => {
295 Ok(__Field::m_footPlantedAnkleHeightMS)
296 }
297 "footRaisedAnkleHeightMS" => {
298 Ok(__Field::m_footRaisedAnkleHeightMS)
299 }
300 "maxAnkleHeightMS" => Ok(__Field::m_maxAnkleHeightMS),
301 "minAnkleHeightMS" => Ok(__Field::m_minAnkleHeightMS),
302 "maxKneeAngleDegrees" => Ok(__Field::m_maxKneeAngleDegrees),
303 "minKneeAngleDegrees" => Ok(__Field::m_minKneeAngleDegrees),
304 "verticalError" => Ok(__Field::m_verticalError),
305 "maxAnkleAngleDegrees" => Ok(__Field::m_maxAnkleAngleDegrees),
306 "hipIndex" => Ok(__Field::m_hipIndex),
307 "kneeIndex" => Ok(__Field::m_kneeIndex),
308 "ankleIndex" => Ok(__Field::m_ankleIndex),
309 "hitSomething" => Ok(__Field::m_hitSomething),
310 "isPlantedMS" => Ok(__Field::m_isPlantedMS),
311 "isOriginalAnkleTransformMSSet" => {
312 Ok(__Field::m_isOriginalAnkleTransformMSSet)
313 }
314 _ => Ok(__Field::__ignore),
315 }
316 }
317 }
318 impl<'de> _serde::Deserialize<'de> for __Field {
319 #[inline]
320 fn deserialize<__D>(
321 __deserializer: __D,
322 ) -> core::result::Result<Self, __D::Error>
323 where
324 __D: _serde::Deserializer<'de>,
325 {
326 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
327 }
328 }
329 struct __hkbFootIkModifierLegVisitor<'de> {
330 marker: _serde::__private::PhantomData<hkbFootIkModifierLeg>,
331 lifetime: _serde::__private::PhantomData<&'de ()>,
332 }
333 #[allow(clippy::match_single_binding)]
334 #[allow(clippy::reversed_empty_ranges)]
335 #[allow(clippy::single_match)]
336 impl<'de> _serde::de::Visitor<'de> for __hkbFootIkModifierLegVisitor<'de> {
337 type Value = hkbFootIkModifierLeg;
338 fn expecting(
339 &self,
340 __formatter: &mut core::fmt::Formatter,
341 ) -> core::fmt::Result {
342 core::fmt::Formatter::write_str(
343 __formatter,
344 "struct hkbFootIkModifierLeg",
345 )
346 }
347 fn visit_struct_for_bytes<__A>(
348 self,
349 mut __map: __A,
350 ) -> _serde::__private::Result<Self::Value, __A::Error>
351 where
352 __A: _serde::de::MapAccess<'de>,
353 {
354 let __ptr = __A::class_ptr(&mut __map);
355 let mut m_originalAnkleTransformMS: _serde::__private::Option<
356 QsTransform,
357 > = _serde::__private::None;
358 let mut m_prevAnkleRotLS: _serde::__private::Option<Quaternion> = _serde::__private::None;
359 let mut m_kneeAxisLS: _serde::__private::Option<Vector4> = _serde::__private::None;
360 let mut m_footEndLS: _serde::__private::Option<Vector4> = _serde::__private::None;
361 let mut m_ungroundedEvent: _serde::__private::Option<
362 hkbEventProperty,
363 > = _serde::__private::None;
364 let mut m_footPlantedAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
365 let mut m_footRaisedAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
366 let mut m_maxAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
367 let mut m_minAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
368 let mut m_maxKneeAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
369 let mut m_minKneeAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
370 let mut m_verticalError: _serde::__private::Option<f32> = _serde::__private::None;
371 let mut m_maxAnkleAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
372 let mut m_hipIndex: _serde::__private::Option<i16> = _serde::__private::None;
373 let mut m_kneeIndex: _serde::__private::Option<i16> = _serde::__private::None;
374 let mut m_ankleIndex: _serde::__private::Option<i16> = _serde::__private::None;
375 let mut m_hitSomething: _serde::__private::Option<bool> = _serde::__private::None;
376 let mut m_isPlantedMS: _serde::__private::Option<bool> = _serde::__private::None;
377 let mut m_isOriginalAnkleTransformMSSet: _serde::__private::Option<
378 bool,
379 > = _serde::__private::None;
380 for i in 0..19usize {
381 match i {
382 0usize => {
383 if _serde::__private::Option::is_some(
384 &m_originalAnkleTransformMS,
385 ) {
386 return _serde::__private::Err(
387 <__A::Error as _serde::de::Error>::duplicate_field(
388 "originalAnkleTransformMS",
389 ),
390 );
391 }
392 m_originalAnkleTransformMS = _serde::__private::Some(
393 match __A::next_value::<QsTransform>(&mut __map) {
394 _serde::__private::Ok(__val) => __val,
395 _serde::__private::Err(__err) => {
396 return _serde::__private::Err(__err);
397 }
398 },
399 );
400 }
401 1usize => {
402 if _serde::__private::Option::is_some(&m_prevAnkleRotLS) {
403 return _serde::__private::Err(
404 <__A::Error as _serde::de::Error>::duplicate_field(
405 "prevAnkleRotLS",
406 ),
407 );
408 }
409 m_prevAnkleRotLS = _serde::__private::Some(
410 match __A::next_value::<Quaternion>(&mut __map) {
411 _serde::__private::Ok(__val) => __val,
412 _serde::__private::Err(__err) => {
413 return _serde::__private::Err(__err);
414 }
415 },
416 );
417 }
418 2usize => {
419 if _serde::__private::Option::is_some(&m_kneeAxisLS) {
420 return _serde::__private::Err(
421 <__A::Error as _serde::de::Error>::duplicate_field(
422 "kneeAxisLS",
423 ),
424 );
425 }
426 m_kneeAxisLS = _serde::__private::Some(
427 match __A::next_value::<Vector4>(&mut __map) {
428 _serde::__private::Ok(__val) => __val,
429 _serde::__private::Err(__err) => {
430 return _serde::__private::Err(__err);
431 }
432 },
433 );
434 }
435 3usize => {
436 if _serde::__private::Option::is_some(&m_footEndLS) {
437 return _serde::__private::Err(
438 <__A::Error as _serde::de::Error>::duplicate_field(
439 "footEndLS",
440 ),
441 );
442 }
443 m_footEndLS = _serde::__private::Some(
444 match __A::next_value::<Vector4>(&mut __map) {
445 _serde::__private::Ok(__val) => __val,
446 _serde::__private::Err(__err) => {
447 return _serde::__private::Err(__err);
448 }
449 },
450 );
451 }
452 4usize => {
453 if _serde::__private::Option::is_some(&m_ungroundedEvent) {
454 return _serde::__private::Err(
455 <__A::Error as _serde::de::Error>::duplicate_field(
456 "ungroundedEvent",
457 ),
458 );
459 }
460 m_ungroundedEvent = _serde::__private::Some(
461 match __A::next_value::<hkbEventProperty>(&mut __map) {
462 _serde::__private::Ok(__val) => __val,
463 _serde::__private::Err(__err) => {
464 return _serde::__private::Err(__err);
465 }
466 },
467 );
468 }
469 5usize => {
470 if _serde::__private::Option::is_some(
471 &m_footPlantedAnkleHeightMS,
472 ) {
473 return _serde::__private::Err(
474 <__A::Error as _serde::de::Error>::duplicate_field(
475 "footPlantedAnkleHeightMS",
476 ),
477 );
478 }
479 m_footPlantedAnkleHeightMS = _serde::__private::Some(
480 match __A::next_value::<f32>(&mut __map) {
481 _serde::__private::Ok(__val) => __val,
482 _serde::__private::Err(__err) => {
483 return _serde::__private::Err(__err);
484 }
485 },
486 );
487 }
488 6usize => {
489 if _serde::__private::Option::is_some(
490 &m_footRaisedAnkleHeightMS,
491 ) {
492 return _serde::__private::Err(
493 <__A::Error as _serde::de::Error>::duplicate_field(
494 "footRaisedAnkleHeightMS",
495 ),
496 );
497 }
498 m_footRaisedAnkleHeightMS = _serde::__private::Some(
499 match __A::next_value::<f32>(&mut __map) {
500 _serde::__private::Ok(__val) => __val,
501 _serde::__private::Err(__err) => {
502 return _serde::__private::Err(__err);
503 }
504 },
505 );
506 }
507 7usize => {
508 if _serde::__private::Option::is_some(&m_maxAnkleHeightMS) {
509 return _serde::__private::Err(
510 <__A::Error as _serde::de::Error>::duplicate_field(
511 "maxAnkleHeightMS",
512 ),
513 );
514 }
515 m_maxAnkleHeightMS = _serde::__private::Some(
516 match __A::next_value::<f32>(&mut __map) {
517 _serde::__private::Ok(__val) => __val,
518 _serde::__private::Err(__err) => {
519 return _serde::__private::Err(__err);
520 }
521 },
522 );
523 }
524 8usize => {
525 if _serde::__private::Option::is_some(&m_minAnkleHeightMS) {
526 return _serde::__private::Err(
527 <__A::Error as _serde::de::Error>::duplicate_field(
528 "minAnkleHeightMS",
529 ),
530 );
531 }
532 m_minAnkleHeightMS = _serde::__private::Some(
533 match __A::next_value::<f32>(&mut __map) {
534 _serde::__private::Ok(__val) => __val,
535 _serde::__private::Err(__err) => {
536 return _serde::__private::Err(__err);
537 }
538 },
539 );
540 }
541 9usize => {
542 if _serde::__private::Option::is_some(
543 &m_maxKneeAngleDegrees,
544 ) {
545 return _serde::__private::Err(
546 <__A::Error as _serde::de::Error>::duplicate_field(
547 "maxKneeAngleDegrees",
548 ),
549 );
550 }
551 m_maxKneeAngleDegrees = _serde::__private::Some(
552 match __A::next_value::<f32>(&mut __map) {
553 _serde::__private::Ok(__val) => __val,
554 _serde::__private::Err(__err) => {
555 return _serde::__private::Err(__err);
556 }
557 },
558 );
559 }
560 10usize => {
561 if _serde::__private::Option::is_some(
562 &m_minKneeAngleDegrees,
563 ) {
564 return _serde::__private::Err(
565 <__A::Error as _serde::de::Error>::duplicate_field(
566 "minKneeAngleDegrees",
567 ),
568 );
569 }
570 m_minKneeAngleDegrees = _serde::__private::Some(
571 match __A::next_value::<f32>(&mut __map) {
572 _serde::__private::Ok(__val) => __val,
573 _serde::__private::Err(__err) => {
574 return _serde::__private::Err(__err);
575 }
576 },
577 );
578 }
579 11usize => {
580 if _serde::__private::Option::is_some(&m_verticalError) {
581 return _serde::__private::Err(
582 <__A::Error as _serde::de::Error>::duplicate_field(
583 "verticalError",
584 ),
585 );
586 }
587 m_verticalError = _serde::__private::Some(
588 match __A::next_value::<f32>(&mut __map) {
589 _serde::__private::Ok(__val) => __val,
590 _serde::__private::Err(__err) => {
591 return _serde::__private::Err(__err);
592 }
593 },
594 );
595 }
596 12usize => {
597 if _serde::__private::Option::is_some(
598 &m_maxAnkleAngleDegrees,
599 ) {
600 return _serde::__private::Err(
601 <__A::Error as _serde::de::Error>::duplicate_field(
602 "maxAnkleAngleDegrees",
603 ),
604 );
605 }
606 m_maxAnkleAngleDegrees = _serde::__private::Some(
607 match __A::next_value::<f32>(&mut __map) {
608 _serde::__private::Ok(__val) => __val,
609 _serde::__private::Err(__err) => {
610 return _serde::__private::Err(__err);
611 }
612 },
613 );
614 }
615 13usize => {
616 if _serde::__private::Option::is_some(&m_hipIndex) {
617 return _serde::__private::Err(
618 <__A::Error as _serde::de::Error>::duplicate_field(
619 "hipIndex",
620 ),
621 );
622 }
623 m_hipIndex = _serde::__private::Some(
624 match __A::next_value::<i16>(&mut __map) {
625 _serde::__private::Ok(__val) => __val,
626 _serde::__private::Err(__err) => {
627 return _serde::__private::Err(__err);
628 }
629 },
630 );
631 }
632 14usize => {
633 if _serde::__private::Option::is_some(&m_kneeIndex) {
634 return _serde::__private::Err(
635 <__A::Error as _serde::de::Error>::duplicate_field(
636 "kneeIndex",
637 ),
638 );
639 }
640 m_kneeIndex = _serde::__private::Some(
641 match __A::next_value::<i16>(&mut __map) {
642 _serde::__private::Ok(__val) => __val,
643 _serde::__private::Err(__err) => {
644 return _serde::__private::Err(__err);
645 }
646 },
647 );
648 }
649 15usize => {
650 if _serde::__private::Option::is_some(&m_ankleIndex) {
651 return _serde::__private::Err(
652 <__A::Error as _serde::de::Error>::duplicate_field(
653 "ankleIndex",
654 ),
655 );
656 }
657 m_ankleIndex = _serde::__private::Some(
658 match __A::next_value::<i16>(&mut __map) {
659 _serde::__private::Ok(__val) => __val,
660 _serde::__private::Err(__err) => {
661 return _serde::__private::Err(__err);
662 }
663 },
664 );
665 }
666 16usize => {
667 if _serde::__private::Option::is_some(&m_hitSomething) {
668 return _serde::__private::Err(
669 <__A::Error as _serde::de::Error>::duplicate_field(
670 "hitSomething",
671 ),
672 );
673 }
674 m_hitSomething = _serde::__private::Some(
675 match __A::next_value::<bool>(&mut __map) {
676 _serde::__private::Ok(__val) => __val,
677 _serde::__private::Err(__err) => {
678 return _serde::__private::Err(__err);
679 }
680 },
681 );
682 }
683 17usize => {
684 if _serde::__private::Option::is_some(&m_isPlantedMS) {
685 return _serde::__private::Err(
686 <__A::Error as _serde::de::Error>::duplicate_field(
687 "isPlantedMS",
688 ),
689 );
690 }
691 m_isPlantedMS = _serde::__private::Some(
692 match __A::next_value::<bool>(&mut __map) {
693 _serde::__private::Ok(__val) => __val,
694 _serde::__private::Err(__err) => {
695 return _serde::__private::Err(__err);
696 }
697 },
698 );
699 }
700 18usize => {
701 if _serde::__private::Option::is_some(
702 &m_isOriginalAnkleTransformMSSet,
703 ) {
704 return _serde::__private::Err(
705 <__A::Error as _serde::de::Error>::duplicate_field(
706 "isOriginalAnkleTransformMSSet",
707 ),
708 );
709 }
710 m_isOriginalAnkleTransformMSSet = _serde::__private::Some(
711 match __A::next_value::<bool>(&mut __map) {
712 _serde::__private::Ok(__val) => __val,
713 _serde::__private::Err(__err) => {
714 return _serde::__private::Err(__err);
715 }
716 },
717 );
718 }
719 _ => {}
720 }
721 }
722 __A::pad(&mut __map, 15usize, 7usize)?;
723 let m_originalAnkleTransformMS = match m_originalAnkleTransformMS {
724 _serde::__private::Some(__field) => __field,
725 _serde::__private::None => {
726 return _serde::__private::Err(
727 <__A::Error as _serde::de::Error>::missing_field(
728 "originalAnkleTransformMS",
729 ),
730 );
731 }
732 };
733 let m_prevAnkleRotLS = match m_prevAnkleRotLS {
734 _serde::__private::Some(__field) => __field,
735 _serde::__private::None => {
736 return _serde::__private::Err(
737 <__A::Error as _serde::de::Error>::missing_field(
738 "prevAnkleRotLS",
739 ),
740 );
741 }
742 };
743 let m_kneeAxisLS = match m_kneeAxisLS {
744 _serde::__private::Some(__field) => __field,
745 _serde::__private::None => {
746 return _serde::__private::Err(
747 <__A::Error as _serde::de::Error>::missing_field(
748 "kneeAxisLS",
749 ),
750 );
751 }
752 };
753 let m_footEndLS = match m_footEndLS {
754 _serde::__private::Some(__field) => __field,
755 _serde::__private::None => {
756 return _serde::__private::Err(
757 <__A::Error as _serde::de::Error>::missing_field(
758 "footEndLS",
759 ),
760 );
761 }
762 };
763 let m_ungroundedEvent = match m_ungroundedEvent {
764 _serde::__private::Some(__field) => __field,
765 _serde::__private::None => {
766 return _serde::__private::Err(
767 <__A::Error as _serde::de::Error>::missing_field(
768 "ungroundedEvent",
769 ),
770 );
771 }
772 };
773 let m_footPlantedAnkleHeightMS = match m_footPlantedAnkleHeightMS {
774 _serde::__private::Some(__field) => __field,
775 _serde::__private::None => {
776 return _serde::__private::Err(
777 <__A::Error as _serde::de::Error>::missing_field(
778 "footPlantedAnkleHeightMS",
779 ),
780 );
781 }
782 };
783 let m_footRaisedAnkleHeightMS = match m_footRaisedAnkleHeightMS {
784 _serde::__private::Some(__field) => __field,
785 _serde::__private::None => {
786 return _serde::__private::Err(
787 <__A::Error as _serde::de::Error>::missing_field(
788 "footRaisedAnkleHeightMS",
789 ),
790 );
791 }
792 };
793 let m_maxAnkleHeightMS = match m_maxAnkleHeightMS {
794 _serde::__private::Some(__field) => __field,
795 _serde::__private::None => {
796 return _serde::__private::Err(
797 <__A::Error as _serde::de::Error>::missing_field(
798 "maxAnkleHeightMS",
799 ),
800 );
801 }
802 };
803 let m_minAnkleHeightMS = match m_minAnkleHeightMS {
804 _serde::__private::Some(__field) => __field,
805 _serde::__private::None => {
806 return _serde::__private::Err(
807 <__A::Error as _serde::de::Error>::missing_field(
808 "minAnkleHeightMS",
809 ),
810 );
811 }
812 };
813 let m_maxKneeAngleDegrees = match m_maxKneeAngleDegrees {
814 _serde::__private::Some(__field) => __field,
815 _serde::__private::None => {
816 return _serde::__private::Err(
817 <__A::Error as _serde::de::Error>::missing_field(
818 "maxKneeAngleDegrees",
819 ),
820 );
821 }
822 };
823 let m_minKneeAngleDegrees = match m_minKneeAngleDegrees {
824 _serde::__private::Some(__field) => __field,
825 _serde::__private::None => {
826 return _serde::__private::Err(
827 <__A::Error as _serde::de::Error>::missing_field(
828 "minKneeAngleDegrees",
829 ),
830 );
831 }
832 };
833 let m_verticalError = match m_verticalError {
834 _serde::__private::Some(__field) => __field,
835 _serde::__private::None => {
836 return _serde::__private::Err(
837 <__A::Error as _serde::de::Error>::missing_field(
838 "verticalError",
839 ),
840 );
841 }
842 };
843 let m_maxAnkleAngleDegrees = match m_maxAnkleAngleDegrees {
844 _serde::__private::Some(__field) => __field,
845 _serde::__private::None => {
846 return _serde::__private::Err(
847 <__A::Error as _serde::de::Error>::missing_field(
848 "maxAnkleAngleDegrees",
849 ),
850 );
851 }
852 };
853 let m_hipIndex = match m_hipIndex {
854 _serde::__private::Some(__field) => __field,
855 _serde::__private::None => {
856 return _serde::__private::Err(
857 <__A::Error as _serde::de::Error>::missing_field("hipIndex"),
858 );
859 }
860 };
861 let m_kneeIndex = match m_kneeIndex {
862 _serde::__private::Some(__field) => __field,
863 _serde::__private::None => {
864 return _serde::__private::Err(
865 <__A::Error as _serde::de::Error>::missing_field(
866 "kneeIndex",
867 ),
868 );
869 }
870 };
871 let m_ankleIndex = match m_ankleIndex {
872 _serde::__private::Some(__field) => __field,
873 _serde::__private::None => {
874 return _serde::__private::Err(
875 <__A::Error as _serde::de::Error>::missing_field(
876 "ankleIndex",
877 ),
878 );
879 }
880 };
881 let m_hitSomething = match m_hitSomething {
882 _serde::__private::Some(__field) => __field,
883 _serde::__private::None => {
884 return _serde::__private::Err(
885 <__A::Error as _serde::de::Error>::missing_field(
886 "hitSomething",
887 ),
888 );
889 }
890 };
891 let m_isPlantedMS = match m_isPlantedMS {
892 _serde::__private::Some(__field) => __field,
893 _serde::__private::None => {
894 return _serde::__private::Err(
895 <__A::Error as _serde::de::Error>::missing_field(
896 "isPlantedMS",
897 ),
898 );
899 }
900 };
901 let m_isOriginalAnkleTransformMSSet = match m_isOriginalAnkleTransformMSSet {
902 _serde::__private::Some(__field) => __field,
903 _serde::__private::None => {
904 return _serde::__private::Err(
905 <__A::Error as _serde::de::Error>::missing_field(
906 "isOriginalAnkleTransformMSSet",
907 ),
908 );
909 }
910 };
911 _serde::__private::Ok(hkbFootIkModifierLeg {
912 __ptr,
913 m_originalAnkleTransformMS,
914 m_prevAnkleRotLS,
915 m_kneeAxisLS,
916 m_footEndLS,
917 m_ungroundedEvent,
918 m_footPlantedAnkleHeightMS,
919 m_footRaisedAnkleHeightMS,
920 m_maxAnkleHeightMS,
921 m_minAnkleHeightMS,
922 m_maxKneeAngleDegrees,
923 m_minKneeAngleDegrees,
924 m_verticalError,
925 m_maxAnkleAngleDegrees,
926 m_hipIndex,
927 m_kneeIndex,
928 m_ankleIndex,
929 m_hitSomething,
930 m_isPlantedMS,
931 m_isOriginalAnkleTransformMSSet,
932 })
933 }
934 #[allow(clippy::manual_unwrap_or_default)]
935 fn visit_struct<__A>(
936 self,
937 mut __map: __A,
938 ) -> _serde::__private::Result<Self::Value, __A::Error>
939 where
940 __A: _serde::de::MapAccess<'de>,
941 {
942 let mut m_originalAnkleTransformMS: _serde::__private::Option<
943 QsTransform,
944 > = _serde::__private::None;
945 let mut m_kneeAxisLS: _serde::__private::Option<Vector4> = _serde::__private::None;
946 let mut m_footEndLS: _serde::__private::Option<Vector4> = _serde::__private::None;
947 let mut m_ungroundedEvent: _serde::__private::Option<
948 hkbEventProperty,
949 > = _serde::__private::None;
950 let mut m_footPlantedAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
951 let mut m_footRaisedAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
952 let mut m_maxAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
953 let mut m_minAnkleHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
954 let mut m_maxKneeAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
955 let mut m_minKneeAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
956 let mut m_verticalError: _serde::__private::Option<f32> = _serde::__private::None;
957 let mut m_maxAnkleAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
958 let mut m_hipIndex: _serde::__private::Option<i16> = _serde::__private::None;
959 let mut m_kneeIndex: _serde::__private::Option<i16> = _serde::__private::None;
960 let mut m_ankleIndex: _serde::__private::Option<i16> = _serde::__private::None;
961 let mut m_hitSomething: _serde::__private::Option<bool> = _serde::__private::None;
962 let mut m_isPlantedMS: _serde::__private::Option<bool> = _serde::__private::None;
963 let mut m_isOriginalAnkleTransformMSSet: _serde::__private::Option<
964 bool,
965 > = _serde::__private::None;
966 while let _serde::__private::Some(__key) = {
967 __A::next_key::<__Field>(&mut __map)?
968 } {
969 match __key {
970 __Field::m_originalAnkleTransformMS => {
971 #[cfg(
972 any(feature = "strict", feature = "ignore_duplicates")
973 )]
974 if _serde::__private::Option::is_some(
975 &m_originalAnkleTransformMS,
976 ) {
977 #[cfg(feature = "ignore_duplicates")]
978 {
979 __A::skip_value(&mut __map)?;
980 continue;
981 }
982 #[cfg(feature = "strict")]
983 return _serde::__private::Err(
984 <__A::Error as _serde::de::Error>::duplicate_field(
985 "originalAnkleTransformMS",
986 ),
987 );
988 }
989 m_originalAnkleTransformMS = _serde::__private::Some(
990 match __A::next_value::<QsTransform>(&mut __map) {
991 _serde::__private::Ok(__val) => __val,
992 _serde::__private::Err(__err) => {
993 return _serde::__private::Err(__err);
994 }
995 },
996 );
997 }
998 __Field::m_kneeAxisLS => {
999 #[cfg(
1000 any(feature = "strict", feature = "ignore_duplicates")
1001 )]
1002 if _serde::__private::Option::is_some(&m_kneeAxisLS) {
1003 #[cfg(feature = "ignore_duplicates")]
1004 {
1005 __A::skip_value(&mut __map)?;
1006 continue;
1007 }
1008 #[cfg(feature = "strict")]
1009 return _serde::__private::Err(
1010 <__A::Error as _serde::de::Error>::duplicate_field(
1011 "kneeAxisLS",
1012 ),
1013 );
1014 }
1015 m_kneeAxisLS = _serde::__private::Some(
1016 match __A::next_value::<Vector4>(&mut __map) {
1017 _serde::__private::Ok(__val) => __val,
1018 _serde::__private::Err(__err) => {
1019 return _serde::__private::Err(__err);
1020 }
1021 },
1022 );
1023 }
1024 __Field::m_footEndLS => {
1025 #[cfg(
1026 any(feature = "strict", feature = "ignore_duplicates")
1027 )]
1028 if _serde::__private::Option::is_some(&m_footEndLS) {
1029 #[cfg(feature = "ignore_duplicates")]
1030 {
1031 __A::skip_value(&mut __map)?;
1032 continue;
1033 }
1034 #[cfg(feature = "strict")]
1035 return _serde::__private::Err(
1036 <__A::Error as _serde::de::Error>::duplicate_field(
1037 "footEndLS",
1038 ),
1039 );
1040 }
1041 m_footEndLS = _serde::__private::Some(
1042 match __A::next_value::<Vector4>(&mut __map) {
1043 _serde::__private::Ok(__val) => __val,
1044 _serde::__private::Err(__err) => {
1045 return _serde::__private::Err(__err);
1046 }
1047 },
1048 );
1049 }
1050 __Field::m_ungroundedEvent => {
1051 #[cfg(
1052 any(feature = "strict", feature = "ignore_duplicates")
1053 )]
1054 if _serde::__private::Option::is_some(&m_ungroundedEvent) {
1055 #[cfg(feature = "ignore_duplicates")]
1056 {
1057 __A::skip_value(&mut __map)?;
1058 continue;
1059 }
1060 #[cfg(feature = "strict")]
1061 return _serde::__private::Err(
1062 <__A::Error as _serde::de::Error>::duplicate_field(
1063 "ungroundedEvent",
1064 ),
1065 );
1066 }
1067 m_ungroundedEvent = _serde::__private::Some(
1068 match __A::next_value::<hkbEventProperty>(&mut __map) {
1069 _serde::__private::Ok(__val) => __val,
1070 _serde::__private::Err(__err) => {
1071 return _serde::__private::Err(__err);
1072 }
1073 },
1074 );
1075 }
1076 __Field::m_footPlantedAnkleHeightMS => {
1077 #[cfg(
1078 any(feature = "strict", feature = "ignore_duplicates")
1079 )]
1080 if _serde::__private::Option::is_some(
1081 &m_footPlantedAnkleHeightMS,
1082 ) {
1083 #[cfg(feature = "ignore_duplicates")]
1084 {
1085 __A::skip_value(&mut __map)?;
1086 continue;
1087 }
1088 #[cfg(feature = "strict")]
1089 return _serde::__private::Err(
1090 <__A::Error as _serde::de::Error>::duplicate_field(
1091 "footPlantedAnkleHeightMS",
1092 ),
1093 );
1094 }
1095 m_footPlantedAnkleHeightMS = _serde::__private::Some(
1096 match __A::next_value::<f32>(&mut __map) {
1097 _serde::__private::Ok(__val) => __val,
1098 _serde::__private::Err(__err) => {
1099 return _serde::__private::Err(__err);
1100 }
1101 },
1102 );
1103 }
1104 __Field::m_footRaisedAnkleHeightMS => {
1105 #[cfg(
1106 any(feature = "strict", feature = "ignore_duplicates")
1107 )]
1108 if _serde::__private::Option::is_some(
1109 &m_footRaisedAnkleHeightMS,
1110 ) {
1111 #[cfg(feature = "ignore_duplicates")]
1112 {
1113 __A::skip_value(&mut __map)?;
1114 continue;
1115 }
1116 #[cfg(feature = "strict")]
1117 return _serde::__private::Err(
1118 <__A::Error as _serde::de::Error>::duplicate_field(
1119 "footRaisedAnkleHeightMS",
1120 ),
1121 );
1122 }
1123 m_footRaisedAnkleHeightMS = _serde::__private::Some(
1124 match __A::next_value::<f32>(&mut __map) {
1125 _serde::__private::Ok(__val) => __val,
1126 _serde::__private::Err(__err) => {
1127 return _serde::__private::Err(__err);
1128 }
1129 },
1130 );
1131 }
1132 __Field::m_maxAnkleHeightMS => {
1133 #[cfg(
1134 any(feature = "strict", feature = "ignore_duplicates")
1135 )]
1136 if _serde::__private::Option::is_some(&m_maxAnkleHeightMS) {
1137 #[cfg(feature = "ignore_duplicates")]
1138 {
1139 __A::skip_value(&mut __map)?;
1140 continue;
1141 }
1142 #[cfg(feature = "strict")]
1143 return _serde::__private::Err(
1144 <__A::Error as _serde::de::Error>::duplicate_field(
1145 "maxAnkleHeightMS",
1146 ),
1147 );
1148 }
1149 m_maxAnkleHeightMS = _serde::__private::Some(
1150 match __A::next_value::<f32>(&mut __map) {
1151 _serde::__private::Ok(__val) => __val,
1152 _serde::__private::Err(__err) => {
1153 return _serde::__private::Err(__err);
1154 }
1155 },
1156 );
1157 }
1158 __Field::m_minAnkleHeightMS => {
1159 #[cfg(
1160 any(feature = "strict", feature = "ignore_duplicates")
1161 )]
1162 if _serde::__private::Option::is_some(&m_minAnkleHeightMS) {
1163 #[cfg(feature = "ignore_duplicates")]
1164 {
1165 __A::skip_value(&mut __map)?;
1166 continue;
1167 }
1168 #[cfg(feature = "strict")]
1169 return _serde::__private::Err(
1170 <__A::Error as _serde::de::Error>::duplicate_field(
1171 "minAnkleHeightMS",
1172 ),
1173 );
1174 }
1175 m_minAnkleHeightMS = _serde::__private::Some(
1176 match __A::next_value::<f32>(&mut __map) {
1177 _serde::__private::Ok(__val) => __val,
1178 _serde::__private::Err(__err) => {
1179 return _serde::__private::Err(__err);
1180 }
1181 },
1182 );
1183 }
1184 __Field::m_maxKneeAngleDegrees => {
1185 #[cfg(
1186 any(feature = "strict", feature = "ignore_duplicates")
1187 )]
1188 if _serde::__private::Option::is_some(
1189 &m_maxKneeAngleDegrees,
1190 ) {
1191 #[cfg(feature = "ignore_duplicates")]
1192 {
1193 __A::skip_value(&mut __map)?;
1194 continue;
1195 }
1196 #[cfg(feature = "strict")]
1197 return _serde::__private::Err(
1198 <__A::Error as _serde::de::Error>::duplicate_field(
1199 "maxKneeAngleDegrees",
1200 ),
1201 );
1202 }
1203 m_maxKneeAngleDegrees = _serde::__private::Some(
1204 match __A::next_value::<f32>(&mut __map) {
1205 _serde::__private::Ok(__val) => __val,
1206 _serde::__private::Err(__err) => {
1207 return _serde::__private::Err(__err);
1208 }
1209 },
1210 );
1211 }
1212 __Field::m_minKneeAngleDegrees => {
1213 #[cfg(
1214 any(feature = "strict", feature = "ignore_duplicates")
1215 )]
1216 if _serde::__private::Option::is_some(
1217 &m_minKneeAngleDegrees,
1218 ) {
1219 #[cfg(feature = "ignore_duplicates")]
1220 {
1221 __A::skip_value(&mut __map)?;
1222 continue;
1223 }
1224 #[cfg(feature = "strict")]
1225 return _serde::__private::Err(
1226 <__A::Error as _serde::de::Error>::duplicate_field(
1227 "minKneeAngleDegrees",
1228 ),
1229 );
1230 }
1231 m_minKneeAngleDegrees = _serde::__private::Some(
1232 match __A::next_value::<f32>(&mut __map) {
1233 _serde::__private::Ok(__val) => __val,
1234 _serde::__private::Err(__err) => {
1235 return _serde::__private::Err(__err);
1236 }
1237 },
1238 );
1239 }
1240 __Field::m_verticalError => {
1241 #[cfg(
1242 any(feature = "strict", feature = "ignore_duplicates")
1243 )]
1244 if _serde::__private::Option::is_some(&m_verticalError) {
1245 #[cfg(feature = "ignore_duplicates")]
1246 {
1247 __A::skip_value(&mut __map)?;
1248 continue;
1249 }
1250 #[cfg(feature = "strict")]
1251 return _serde::__private::Err(
1252 <__A::Error as _serde::de::Error>::duplicate_field(
1253 "verticalError",
1254 ),
1255 );
1256 }
1257 m_verticalError = _serde::__private::Some(
1258 match __A::next_value::<f32>(&mut __map) {
1259 _serde::__private::Ok(__val) => __val,
1260 _serde::__private::Err(__err) => {
1261 return _serde::__private::Err(__err);
1262 }
1263 },
1264 );
1265 }
1266 __Field::m_maxAnkleAngleDegrees => {
1267 #[cfg(
1268 any(feature = "strict", feature = "ignore_duplicates")
1269 )]
1270 if _serde::__private::Option::is_some(
1271 &m_maxAnkleAngleDegrees,
1272 ) {
1273 #[cfg(feature = "ignore_duplicates")]
1274 {
1275 __A::skip_value(&mut __map)?;
1276 continue;
1277 }
1278 #[cfg(feature = "strict")]
1279 return _serde::__private::Err(
1280 <__A::Error as _serde::de::Error>::duplicate_field(
1281 "maxAnkleAngleDegrees",
1282 ),
1283 );
1284 }
1285 m_maxAnkleAngleDegrees = _serde::__private::Some(
1286 match __A::next_value::<f32>(&mut __map) {
1287 _serde::__private::Ok(__val) => __val,
1288 _serde::__private::Err(__err) => {
1289 return _serde::__private::Err(__err);
1290 }
1291 },
1292 );
1293 }
1294 __Field::m_hipIndex => {
1295 #[cfg(
1296 any(feature = "strict", feature = "ignore_duplicates")
1297 )]
1298 if _serde::__private::Option::is_some(&m_hipIndex) {
1299 #[cfg(feature = "ignore_duplicates")]
1300 {
1301 __A::skip_value(&mut __map)?;
1302 continue;
1303 }
1304 #[cfg(feature = "strict")]
1305 return _serde::__private::Err(
1306 <__A::Error as _serde::de::Error>::duplicate_field(
1307 "hipIndex",
1308 ),
1309 );
1310 }
1311 m_hipIndex = _serde::__private::Some(
1312 match __A::next_value::<i16>(&mut __map) {
1313 _serde::__private::Ok(__val) => __val,
1314 _serde::__private::Err(__err) => {
1315 return _serde::__private::Err(__err);
1316 }
1317 },
1318 );
1319 }
1320 __Field::m_kneeIndex => {
1321 #[cfg(
1322 any(feature = "strict", feature = "ignore_duplicates")
1323 )]
1324 if _serde::__private::Option::is_some(&m_kneeIndex) {
1325 #[cfg(feature = "ignore_duplicates")]
1326 {
1327 __A::skip_value(&mut __map)?;
1328 continue;
1329 }
1330 #[cfg(feature = "strict")]
1331 return _serde::__private::Err(
1332 <__A::Error as _serde::de::Error>::duplicate_field(
1333 "kneeIndex",
1334 ),
1335 );
1336 }
1337 m_kneeIndex = _serde::__private::Some(
1338 match __A::next_value::<i16>(&mut __map) {
1339 _serde::__private::Ok(__val) => __val,
1340 _serde::__private::Err(__err) => {
1341 return _serde::__private::Err(__err);
1342 }
1343 },
1344 );
1345 }
1346 __Field::m_ankleIndex => {
1347 #[cfg(
1348 any(feature = "strict", feature = "ignore_duplicates")
1349 )]
1350 if _serde::__private::Option::is_some(&m_ankleIndex) {
1351 #[cfg(feature = "ignore_duplicates")]
1352 {
1353 __A::skip_value(&mut __map)?;
1354 continue;
1355 }
1356 #[cfg(feature = "strict")]
1357 return _serde::__private::Err(
1358 <__A::Error as _serde::de::Error>::duplicate_field(
1359 "ankleIndex",
1360 ),
1361 );
1362 }
1363 m_ankleIndex = _serde::__private::Some(
1364 match __A::next_value::<i16>(&mut __map) {
1365 _serde::__private::Ok(__val) => __val,
1366 _serde::__private::Err(__err) => {
1367 return _serde::__private::Err(__err);
1368 }
1369 },
1370 );
1371 }
1372 __Field::m_hitSomething => {
1373 #[cfg(
1374 any(feature = "strict", feature = "ignore_duplicates")
1375 )]
1376 if _serde::__private::Option::is_some(&m_hitSomething) {
1377 #[cfg(feature = "ignore_duplicates")]
1378 {
1379 __A::skip_value(&mut __map)?;
1380 continue;
1381 }
1382 #[cfg(feature = "strict")]
1383 return _serde::__private::Err(
1384 <__A::Error as _serde::de::Error>::duplicate_field(
1385 "hitSomething",
1386 ),
1387 );
1388 }
1389 m_hitSomething = _serde::__private::Some(
1390 match __A::next_value::<bool>(&mut __map) {
1391 _serde::__private::Ok(__val) => __val,
1392 _serde::__private::Err(__err) => {
1393 return _serde::__private::Err(__err);
1394 }
1395 },
1396 );
1397 }
1398 __Field::m_isPlantedMS => {
1399 #[cfg(
1400 any(feature = "strict", feature = "ignore_duplicates")
1401 )]
1402 if _serde::__private::Option::is_some(&m_isPlantedMS) {
1403 #[cfg(feature = "ignore_duplicates")]
1404 {
1405 __A::skip_value(&mut __map)?;
1406 continue;
1407 }
1408 #[cfg(feature = "strict")]
1409 return _serde::__private::Err(
1410 <__A::Error as _serde::de::Error>::duplicate_field(
1411 "isPlantedMS",
1412 ),
1413 );
1414 }
1415 m_isPlantedMS = _serde::__private::Some(
1416 match __A::next_value::<bool>(&mut __map) {
1417 _serde::__private::Ok(__val) => __val,
1418 _serde::__private::Err(__err) => {
1419 return _serde::__private::Err(__err);
1420 }
1421 },
1422 );
1423 }
1424 __Field::m_isOriginalAnkleTransformMSSet => {
1425 #[cfg(
1426 any(feature = "strict", feature = "ignore_duplicates")
1427 )]
1428 if _serde::__private::Option::is_some(
1429 &m_isOriginalAnkleTransformMSSet,
1430 ) {
1431 #[cfg(feature = "ignore_duplicates")]
1432 {
1433 __A::skip_value(&mut __map)?;
1434 continue;
1435 }
1436 #[cfg(feature = "strict")]
1437 return _serde::__private::Err(
1438 <__A::Error as _serde::de::Error>::duplicate_field(
1439 "isOriginalAnkleTransformMSSet",
1440 ),
1441 );
1442 }
1443 m_isOriginalAnkleTransformMSSet = _serde::__private::Some(
1444 match __A::next_value::<bool>(&mut __map) {
1445 _serde::__private::Ok(__val) => __val,
1446 _serde::__private::Err(__err) => {
1447 return _serde::__private::Err(__err);
1448 }
1449 },
1450 );
1451 }
1452 _ => __A::skip_value(&mut __map)?,
1453 }
1454 }
1455 let m_originalAnkleTransformMS = match m_originalAnkleTransformMS {
1456 _serde::__private::Some(__field) => __field,
1457 _serde::__private::None => {
1458 #[cfg(feature = "strict")]
1459 return _serde::__private::Err(
1460 <__A::Error as _serde::de::Error>::missing_field(
1461 "originalAnkleTransformMS",
1462 ),
1463 );
1464 #[cfg(not(feature = "strict"))] Default::default()
1465 }
1466 };
1467 let m_kneeAxisLS = match m_kneeAxisLS {
1468 _serde::__private::Some(__field) => __field,
1469 _serde::__private::None => {
1470 #[cfg(feature = "strict")]
1471 return _serde::__private::Err(
1472 <__A::Error as _serde::de::Error>::missing_field(
1473 "kneeAxisLS",
1474 ),
1475 );
1476 #[cfg(not(feature = "strict"))] Default::default()
1477 }
1478 };
1479 let m_footEndLS = match m_footEndLS {
1480 _serde::__private::Some(__field) => __field,
1481 _serde::__private::None => {
1482 #[cfg(feature = "strict")]
1483 return _serde::__private::Err(
1484 <__A::Error as _serde::de::Error>::missing_field(
1485 "footEndLS",
1486 ),
1487 );
1488 #[cfg(not(feature = "strict"))] Default::default()
1489 }
1490 };
1491 let m_ungroundedEvent = match m_ungroundedEvent {
1492 _serde::__private::Some(__field) => __field,
1493 _serde::__private::None => {
1494 #[cfg(feature = "strict")]
1495 return _serde::__private::Err(
1496 <__A::Error as _serde::de::Error>::missing_field(
1497 "ungroundedEvent",
1498 ),
1499 );
1500 #[cfg(not(feature = "strict"))] Default::default()
1501 }
1502 };
1503 let m_footPlantedAnkleHeightMS = match m_footPlantedAnkleHeightMS {
1504 _serde::__private::Some(__field) => __field,
1505 _serde::__private::None => {
1506 #[cfg(feature = "strict")]
1507 return _serde::__private::Err(
1508 <__A::Error as _serde::de::Error>::missing_field(
1509 "footPlantedAnkleHeightMS",
1510 ),
1511 );
1512 #[cfg(not(feature = "strict"))] Default::default()
1513 }
1514 };
1515 let m_footRaisedAnkleHeightMS = match m_footRaisedAnkleHeightMS {
1516 _serde::__private::Some(__field) => __field,
1517 _serde::__private::None => {
1518 #[cfg(feature = "strict")]
1519 return _serde::__private::Err(
1520 <__A::Error as _serde::de::Error>::missing_field(
1521 "footRaisedAnkleHeightMS",
1522 ),
1523 );
1524 #[cfg(not(feature = "strict"))] Default::default()
1525 }
1526 };
1527 let m_maxAnkleHeightMS = match m_maxAnkleHeightMS {
1528 _serde::__private::Some(__field) => __field,
1529 _serde::__private::None => {
1530 #[cfg(feature = "strict")]
1531 return _serde::__private::Err(
1532 <__A::Error as _serde::de::Error>::missing_field(
1533 "maxAnkleHeightMS",
1534 ),
1535 );
1536 #[cfg(not(feature = "strict"))] Default::default()
1537 }
1538 };
1539 let m_minAnkleHeightMS = match m_minAnkleHeightMS {
1540 _serde::__private::Some(__field) => __field,
1541 _serde::__private::None => {
1542 #[cfg(feature = "strict")]
1543 return _serde::__private::Err(
1544 <__A::Error as _serde::de::Error>::missing_field(
1545 "minAnkleHeightMS",
1546 ),
1547 );
1548 #[cfg(not(feature = "strict"))] Default::default()
1549 }
1550 };
1551 let m_maxKneeAngleDegrees = match m_maxKneeAngleDegrees {
1552 _serde::__private::Some(__field) => __field,
1553 _serde::__private::None => {
1554 #[cfg(feature = "strict")]
1555 return _serde::__private::Err(
1556 <__A::Error as _serde::de::Error>::missing_field(
1557 "maxKneeAngleDegrees",
1558 ),
1559 );
1560 #[cfg(not(feature = "strict"))] Default::default()
1561 }
1562 };
1563 let m_minKneeAngleDegrees = match m_minKneeAngleDegrees {
1564 _serde::__private::Some(__field) => __field,
1565 _serde::__private::None => {
1566 #[cfg(feature = "strict")]
1567 return _serde::__private::Err(
1568 <__A::Error as _serde::de::Error>::missing_field(
1569 "minKneeAngleDegrees",
1570 ),
1571 );
1572 #[cfg(not(feature = "strict"))] Default::default()
1573 }
1574 };
1575 let m_verticalError = match m_verticalError {
1576 _serde::__private::Some(__field) => __field,
1577 _serde::__private::None => {
1578 #[cfg(feature = "strict")]
1579 return _serde::__private::Err(
1580 <__A::Error as _serde::de::Error>::missing_field(
1581 "verticalError",
1582 ),
1583 );
1584 #[cfg(not(feature = "strict"))] Default::default()
1585 }
1586 };
1587 let m_maxAnkleAngleDegrees = match m_maxAnkleAngleDegrees {
1588 _serde::__private::Some(__field) => __field,
1589 _serde::__private::None => {
1590 #[cfg(feature = "strict")]
1591 return _serde::__private::Err(
1592 <__A::Error as _serde::de::Error>::missing_field(
1593 "maxAnkleAngleDegrees",
1594 ),
1595 );
1596 #[cfg(not(feature = "strict"))] Default::default()
1597 }
1598 };
1599 let m_hipIndex = match m_hipIndex {
1600 _serde::__private::Some(__field) => __field,
1601 _serde::__private::None => {
1602 #[cfg(feature = "strict")]
1603 return _serde::__private::Err(
1604 <__A::Error as _serde::de::Error>::missing_field("hipIndex"),
1605 );
1606 #[cfg(not(feature = "strict"))] Default::default()
1607 }
1608 };
1609 let m_kneeIndex = match m_kneeIndex {
1610 _serde::__private::Some(__field) => __field,
1611 _serde::__private::None => {
1612 #[cfg(feature = "strict")]
1613 return _serde::__private::Err(
1614 <__A::Error as _serde::de::Error>::missing_field(
1615 "kneeIndex",
1616 ),
1617 );
1618 #[cfg(not(feature = "strict"))] Default::default()
1619 }
1620 };
1621 let m_ankleIndex = match m_ankleIndex {
1622 _serde::__private::Some(__field) => __field,
1623 _serde::__private::None => {
1624 #[cfg(feature = "strict")]
1625 return _serde::__private::Err(
1626 <__A::Error as _serde::de::Error>::missing_field(
1627 "ankleIndex",
1628 ),
1629 );
1630 #[cfg(not(feature = "strict"))] Default::default()
1631 }
1632 };
1633 let m_hitSomething = match m_hitSomething {
1634 _serde::__private::Some(__field) => __field,
1635 _serde::__private::None => {
1636 #[cfg(feature = "strict")]
1637 return _serde::__private::Err(
1638 <__A::Error as _serde::de::Error>::missing_field(
1639 "hitSomething",
1640 ),
1641 );
1642 #[cfg(not(feature = "strict"))] Default::default()
1643 }
1644 };
1645 let m_isPlantedMS = match m_isPlantedMS {
1646 _serde::__private::Some(__field) => __field,
1647 _serde::__private::None => {
1648 #[cfg(feature = "strict")]
1649 return _serde::__private::Err(
1650 <__A::Error as _serde::de::Error>::missing_field(
1651 "isPlantedMS",
1652 ),
1653 );
1654 #[cfg(not(feature = "strict"))] Default::default()
1655 }
1656 };
1657 let m_isOriginalAnkleTransformMSSet = match m_isOriginalAnkleTransformMSSet {
1658 _serde::__private::Some(__field) => __field,
1659 _serde::__private::None => {
1660 #[cfg(feature = "strict")]
1661 return _serde::__private::Err(
1662 <__A::Error as _serde::de::Error>::missing_field(
1663 "isOriginalAnkleTransformMSSet",
1664 ),
1665 );
1666 #[cfg(not(feature = "strict"))] Default::default()
1667 }
1668 };
1669 let __ptr = __A::class_ptr(&mut __map);
1670 _serde::__private::Ok(hkbFootIkModifierLeg {
1671 __ptr,
1672 m_originalAnkleTransformMS,
1673 m_kneeAxisLS,
1674 m_footEndLS,
1675 m_ungroundedEvent,
1676 m_footPlantedAnkleHeightMS,
1677 m_footRaisedAnkleHeightMS,
1678 m_maxAnkleHeightMS,
1679 m_minAnkleHeightMS,
1680 m_maxKneeAngleDegrees,
1681 m_minKneeAngleDegrees,
1682 m_verticalError,
1683 m_maxAnkleAngleDegrees,
1684 m_hipIndex,
1685 m_kneeIndex,
1686 m_ankleIndex,
1687 m_hitSomething,
1688 m_isPlantedMS,
1689 m_isOriginalAnkleTransformMSSet,
1690 ..Default::default()
1691 })
1692 }
1693 }
1694 const FIELDS: &[&str] = &[
1695 "originalAnkleTransformMS",
1696 "prevAnkleRotLS",
1697 "kneeAxisLS",
1698 "footEndLS",
1699 "ungroundedEvent",
1700 "footPlantedAnkleHeightMS",
1701 "footRaisedAnkleHeightMS",
1702 "maxAnkleHeightMS",
1703 "minAnkleHeightMS",
1704 "maxKneeAngleDegrees",
1705 "minKneeAngleDegrees",
1706 "verticalError",
1707 "maxAnkleAngleDegrees",
1708 "hipIndex",
1709 "kneeIndex",
1710 "ankleIndex",
1711 "hitSomething",
1712 "isPlantedMS",
1713 "isOriginalAnkleTransformMSSet",
1714 ];
1715 _serde::Deserializer::deserialize_struct(
1716 deserializer,
1717 "hkbFootIkModifierLeg",
1718 FIELDS,
1719 __hkbFootIkModifierLegVisitor {
1720 marker: _serde::__private::PhantomData::<hkbFootIkModifierLeg>,
1721 lifetime: _serde::__private::PhantomData,
1722 },
1723 )
1724 }
1725 }
1726};