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