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