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 hkbFootIkModifier<'a> {
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 #[cfg_attr(feature = "serde", serde(borrow))]
30 pub parent: hkbModifier<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "gains"))]
36 #[cfg_attr(feature = "serde", serde(rename = "gains"))]
37 pub m_gains: hkbFootIkGains,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "legs"))]
43 #[cfg_attr(feature = "serde", serde(rename = "legs"))]
44 pub m_legs: Vec<hkbFootIkModifierLeg>,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "raycastDistanceUp"))]
50 #[cfg_attr(feature = "serde", serde(rename = "raycastDistanceUp"))]
51 pub m_raycastDistanceUp: f32,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "raycastDistanceDown"))]
57 #[cfg_attr(feature = "serde", serde(rename = "raycastDistanceDown"))]
58 pub m_raycastDistanceDown: f32,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "originalGroundHeightMS"))]
64 #[cfg_attr(feature = "serde", serde(rename = "originalGroundHeightMS"))]
65 pub m_originalGroundHeightMS: f32,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "errorOut"))]
71 #[cfg_attr(feature = "serde", serde(rename = "errorOut"))]
72 pub m_errorOut: f32,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "errorOutTranslation"))]
78 #[cfg_attr(feature = "serde", serde(rename = "errorOutTranslation"))]
79 pub m_errorOutTranslation: Vector4,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "alignWithGroundRotation"))]
85 #[cfg_attr(feature = "serde", serde(rename = "alignWithGroundRotation"))]
86 pub m_alignWithGroundRotation: Quaternion,
87 #[cfg_attr(feature = "json_schema", schemars(rename = "verticalOffset"))]
92 #[cfg_attr(feature = "serde", serde(rename = "verticalOffset"))]
93 pub m_verticalOffset: f32,
94 #[cfg_attr(feature = "json_schema", schemars(rename = "collisionFilterInfo"))]
99 #[cfg_attr(feature = "serde", serde(rename = "collisionFilterInfo"))]
100 pub m_collisionFilterInfo: u32,
101 #[cfg_attr(feature = "json_schema", schemars(rename = "forwardAlignFraction"))]
106 #[cfg_attr(feature = "serde", serde(rename = "forwardAlignFraction"))]
107 pub m_forwardAlignFraction: f32,
108 #[cfg_attr(feature = "json_schema", schemars(rename = "sidewaysAlignFraction"))]
113 #[cfg_attr(feature = "serde", serde(rename = "sidewaysAlignFraction"))]
114 pub m_sidewaysAlignFraction: f32,
115 #[cfg_attr(feature = "json_schema", schemars(rename = "sidewaysSampleWidth"))]
120 #[cfg_attr(feature = "serde", serde(rename = "sidewaysSampleWidth"))]
121 pub m_sidewaysSampleWidth: f32,
122 #[cfg_attr(feature = "json_schema", schemars(rename = "useTrackData"))]
127 #[cfg_attr(feature = "serde", serde(rename = "useTrackData"))]
128 pub m_useTrackData: bool,
129 #[cfg_attr(feature = "json_schema", schemars(rename = "lockFeetWhenPlanted"))]
134 #[cfg_attr(feature = "serde", serde(rename = "lockFeetWhenPlanted"))]
135 pub m_lockFeetWhenPlanted: bool,
136 #[cfg_attr(feature = "json_schema", schemars(rename = "useCharacterUpVector"))]
141 #[cfg_attr(feature = "serde", serde(rename = "useCharacterUpVector"))]
142 pub m_useCharacterUpVector: bool,
143 #[cfg_attr(feature = "json_schema", schemars(rename = "alignMode"))]
148 #[cfg_attr(feature = "serde", serde(rename = "alignMode"))]
149 pub m_alignMode: AlignMode,
150 #[cfg_attr(feature = "json_schema", schemars(rename = "internalLegData"))]
156 #[cfg_attr(feature = "serde", serde(rename = "internalLegData"))]
157 pub m_internalLegData: Vec<hkbFootIkModifierInternalLegData>,
158 #[cfg_attr(feature = "json_schema", schemars(rename = "prevIsFootIkEnabled"))]
164 #[cfg_attr(feature = "serde", serde(rename = "prevIsFootIkEnabled"))]
165 pub m_prevIsFootIkEnabled: f32,
166 #[cfg_attr(feature = "json_schema", schemars(rename = "isSetUp"))]
172 #[cfg_attr(feature = "serde", serde(rename = "isSetUp"))]
173 pub m_isSetUp: bool,
174 #[cfg_attr(feature = "json_schema", schemars(rename = "isGroundPositionValid"))]
180 #[cfg_attr(feature = "serde", serde(rename = "isGroundPositionValid"))]
181 pub m_isGroundPositionValid: bool,
182 #[cfg_attr(feature = "json_schema", schemars(rename = "timeStep"))]
188 #[cfg_attr(feature = "serde", serde(rename = "timeStep"))]
189 pub m_timeStep: f32,
190}
191const _: () = {
192 use havok_serde as _serde;
193 impl<'a> _serde::HavokClass for hkbFootIkModifier<'a> {
194 #[inline]
195 fn name(&self) -> &'static str {
196 "hkbFootIkModifier"
197 }
198 #[inline]
199 fn signature(&self) -> _serde::__private::Signature {
200 _serde::__private::Signature::new(0xed8966c0)
201 }
202 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
203 fn deps_indexes(&self) -> Vec<usize> {
204 let mut v = Vec::new();
205 v.push(self.parent.parent.parent.m_variableBindingSet.get());
206 v.extend(self.m_gains.deps_indexes());
207 v.extend(
208 self
209 .m_legs
210 .iter()
211 .flat_map(|class| class.deps_indexes())
212 .collect::<Vec<usize>>(),
213 );
214 v.extend(
215 self
216 .m_internalLegData
217 .iter()
218 .flat_map(|class| class.deps_indexes())
219 .collect::<Vec<usize>>(),
220 );
221 v
222 }
223 }
224 impl<'a> _serde::Serialize for hkbFootIkModifier<'a> {
225 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
226 where
227 S: _serde::ser::Serializer,
228 {
229 let class_meta = self
230 .__ptr
231 .map(|name| (name, _serde::__private::Signature::new(0xed8966c0)));
232 let mut serializer = __serializer
233 .serialize_struct("hkbFootIkModifier", class_meta, (208u64, 256u64))?;
234 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
235 serializer
236 .skip_field(
237 "memSizeAndFlags",
238 &self.parent.parent.parent.parent.m_memSizeAndFlags,
239 )?;
240 serializer
241 .skip_field(
242 "referenceCount",
243 &self.parent.parent.parent.parent.m_referenceCount,
244 )?;
245 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
246 serializer
247 .serialize_field(
248 "variableBindingSet",
249 &self.parent.parent.parent.m_variableBindingSet,
250 )?;
251 serializer
252 .skip_array_field(
253 "cachedBindables",
254 &self.parent.parent.parent.m_cachedBindables,
255 TypeSize::NonPtr,
256 )?;
257 serializer
258 .skip_field(
259 "areBindablesCached",
260 &self.parent.parent.parent.m_areBindablesCached,
261 )?;
262 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
263 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
264 serializer.serialize_field("name", &self.parent.parent.m_name)?;
265 serializer.skip_field("id", &self.parent.parent.m_id)?;
266 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
267 serializer
268 .skip_fixed_array_field(
269 "padNode",
270 self.parent.parent.m_padNode.as_slice(),
271 TypeSize::NonPtr,
272 )?;
273 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
274 serializer.serialize_field("enable", &self.parent.m_enable)?;
275 serializer
276 .skip_fixed_array_field(
277 "padModifier",
278 self.parent.m_padModifier.as_slice(),
279 TypeSize::NonPtr,
280 )?;
281 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
282 serializer.serialize_field("gains", &self.m_gains)?;
283 serializer
284 .serialize_array_field(
285 "legs",
286 &self.m_legs,
287 TypeSize::Struct {
288 size_x86: 160u64,
289 size_x86_64: 160u64,
290 },
291 )?;
292 serializer.serialize_field("raycastDistanceUp", &self.m_raycastDistanceUp)?;
293 serializer
294 .serialize_field("raycastDistanceDown", &self.m_raycastDistanceDown)?;
295 serializer
296 .serialize_field(
297 "originalGroundHeightMS",
298 &self.m_originalGroundHeightMS,
299 )?;
300 serializer.serialize_field("errorOut", &self.m_errorOut)?;
301 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
302 serializer
303 .serialize_field("errorOutTranslation", &self.m_errorOutTranslation)?;
304 serializer
305 .serialize_field(
306 "alignWithGroundRotation",
307 &self.m_alignWithGroundRotation,
308 )?;
309 serializer.serialize_field("verticalOffset", &self.m_verticalOffset)?;
310 serializer
311 .serialize_field("collisionFilterInfo", &self.m_collisionFilterInfo)?;
312 serializer
313 .serialize_field("forwardAlignFraction", &self.m_forwardAlignFraction)?;
314 serializer
315 .serialize_field(
316 "sidewaysAlignFraction",
317 &self.m_sidewaysAlignFraction,
318 )?;
319 serializer
320 .serialize_field("sidewaysSampleWidth", &self.m_sidewaysSampleWidth)?;
321 serializer.serialize_field("useTrackData", &self.m_useTrackData)?;
322 serializer
323 .serialize_field("lockFeetWhenPlanted", &self.m_lockFeetWhenPlanted)?;
324 serializer
325 .serialize_field("useCharacterUpVector", &self.m_useCharacterUpVector)?;
326 serializer.serialize_field("alignMode", &self.m_alignMode)?;
327 serializer
328 .skip_array_field(
329 "internalLegData",
330 &self.m_internalLegData,
331 TypeSize::Struct {
332 size_x86: 32u64,
333 size_x86_64: 32u64,
334 },
335 )?;
336 serializer.skip_field("prevIsFootIkEnabled", &self.m_prevIsFootIkEnabled)?;
337 serializer.skip_field("isSetUp", &self.m_isSetUp)?;
338 serializer
339 .skip_field("isGroundPositionValid", &self.m_isGroundPositionValid)?;
340 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
341 serializer.skip_field("timeStep", &self.m_timeStep)?;
342 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 12usize].as_slice())?;
343 serializer.end()
344 }
345 }
346};
347#[doc(hidden)]
348#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
349const _: () = {
350 use havok_serde as _serde;
351 #[automatically_derived]
352 impl<'de> _serde::Deserialize<'de> for hkbFootIkModifier<'de> {
353 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
354 where
355 __D: _serde::Deserializer<'de>,
356 {
357 #[allow(non_camel_case_types)]
358 enum __Field {
359 m_variableBindingSet,
360 m_userData,
361 m_name,
362 m_enable,
363 m_gains,
364 m_legs,
365 m_raycastDistanceUp,
366 m_raycastDistanceDown,
367 m_originalGroundHeightMS,
368 m_errorOut,
369 m_errorOutTranslation,
370 m_alignWithGroundRotation,
371 m_verticalOffset,
372 m_collisionFilterInfo,
373 m_forwardAlignFraction,
374 m_sidewaysAlignFraction,
375 m_sidewaysSampleWidth,
376 m_useTrackData,
377 m_lockFeetWhenPlanted,
378 m_useCharacterUpVector,
379 m_alignMode,
380 __ignore,
381 }
382 struct __FieldVisitor;
383 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
384 type Value = __Field;
385 fn expecting(
386 &self,
387 __formatter: &mut core::fmt::Formatter,
388 ) -> core::fmt::Result {
389 core::fmt::Formatter::write_str(__formatter, "field identifier")
390 }
391 #[allow(clippy::match_single_binding)]
393 #[allow(clippy::reversed_empty_ranges)]
394 #[allow(clippy::single_match)]
395 fn visit_key<__E>(
396 self,
397 __value: &str,
398 ) -> core::result::Result<Self::Value, __E>
399 where
400 __E: _serde::de::Error,
401 {
402 match __value {
403 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
404 "userData" => Ok(__Field::m_userData),
405 "name" => Ok(__Field::m_name),
406 "enable" => Ok(__Field::m_enable),
407 "gains" => Ok(__Field::m_gains),
408 "legs" => Ok(__Field::m_legs),
409 "raycastDistanceUp" => Ok(__Field::m_raycastDistanceUp),
410 "raycastDistanceDown" => Ok(__Field::m_raycastDistanceDown),
411 "originalGroundHeightMS" => Ok(__Field::m_originalGroundHeightMS),
412 "errorOut" => Ok(__Field::m_errorOut),
413 "errorOutTranslation" => Ok(__Field::m_errorOutTranslation),
414 "alignWithGroundRotation" => {
415 Ok(__Field::m_alignWithGroundRotation)
416 }
417 "verticalOffset" => Ok(__Field::m_verticalOffset),
418 "collisionFilterInfo" => Ok(__Field::m_collisionFilterInfo),
419 "forwardAlignFraction" => Ok(__Field::m_forwardAlignFraction),
420 "sidewaysAlignFraction" => Ok(__Field::m_sidewaysAlignFraction),
421 "sidewaysSampleWidth" => Ok(__Field::m_sidewaysSampleWidth),
422 "useTrackData" => Ok(__Field::m_useTrackData),
423 "lockFeetWhenPlanted" => Ok(__Field::m_lockFeetWhenPlanted),
424 "useCharacterUpVector" => Ok(__Field::m_useCharacterUpVector),
425 "alignMode" => Ok(__Field::m_alignMode),
426 _ => Ok(__Field::__ignore),
427 }
428 }
429 }
430 impl<'de> _serde::Deserialize<'de> for __Field {
431 #[inline]
432 fn deserialize<__D>(
433 __deserializer: __D,
434 ) -> core::result::Result<Self, __D::Error>
435 where
436 __D: _serde::Deserializer<'de>,
437 {
438 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
439 }
440 }
441 struct __hkbFootIkModifierVisitor<'de> {
442 marker: _serde::__private::PhantomData<hkbFootIkModifier<'de>>,
443 lifetime: _serde::__private::PhantomData<&'de ()>,
444 }
445 #[allow(clippy::match_single_binding)]
446 #[allow(clippy::reversed_empty_ranges)]
447 #[allow(clippy::single_match)]
448 impl<'de> _serde::de::Visitor<'de> for __hkbFootIkModifierVisitor<'de> {
449 type Value = hkbFootIkModifier<'de>;
450 fn expecting(
451 &self,
452 __formatter: &mut core::fmt::Formatter,
453 ) -> core::fmt::Result {
454 core::fmt::Formatter::write_str(
455 __formatter,
456 "struct hkbFootIkModifier",
457 )
458 }
459 fn visit_struct_for_bytes<__A>(
460 self,
461 mut __map: __A,
462 ) -> _serde::__private::Result<Self::Value, __A::Error>
463 where
464 __A: _serde::de::MapAccess<'de>,
465 {
466 let __ptr = __A::class_ptr(&mut __map);
467 let parent = __A::parent_value(&mut __map)?;
468 let mut m_gains: _serde::__private::Option<hkbFootIkGains> = _serde::__private::None;
469 let mut m_legs: _serde::__private::Option<
470 Vec<hkbFootIkModifierLeg>,
471 > = _serde::__private::None;
472 let mut m_raycastDistanceUp: _serde::__private::Option<f32> = _serde::__private::None;
473 let mut m_raycastDistanceDown: _serde::__private::Option<f32> = _serde::__private::None;
474 let mut m_originalGroundHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
475 let mut m_errorOut: _serde::__private::Option<f32> = _serde::__private::None;
476 let mut m_errorOutTranslation: _serde::__private::Option<Vector4> = _serde::__private::None;
477 let mut m_alignWithGroundRotation: _serde::__private::Option<
478 Quaternion,
479 > = _serde::__private::None;
480 let mut m_verticalOffset: _serde::__private::Option<f32> = _serde::__private::None;
481 let mut m_collisionFilterInfo: _serde::__private::Option<u32> = _serde::__private::None;
482 let mut m_forwardAlignFraction: _serde::__private::Option<f32> = _serde::__private::None;
483 let mut m_sidewaysAlignFraction: _serde::__private::Option<f32> = _serde::__private::None;
484 let mut m_sidewaysSampleWidth: _serde::__private::Option<f32> = _serde::__private::None;
485 let mut m_useTrackData: _serde::__private::Option<bool> = _serde::__private::None;
486 let mut m_lockFeetWhenPlanted: _serde::__private::Option<bool> = _serde::__private::None;
487 let mut m_useCharacterUpVector: _serde::__private::Option<bool> = _serde::__private::None;
488 let mut m_alignMode: _serde::__private::Option<AlignMode> = _serde::__private::None;
489 let mut m_internalLegData: _serde::__private::Option<
490 Vec<hkbFootIkModifierInternalLegData>,
491 > = _serde::__private::None;
492 let mut m_prevIsFootIkEnabled: _serde::__private::Option<f32> = _serde::__private::None;
493 let mut m_isSetUp: _serde::__private::Option<bool> = _serde::__private::None;
494 let mut m_isGroundPositionValid: _serde::__private::Option<bool> = _serde::__private::None;
495 let mut m_timeStep: _serde::__private::Option<f32> = _serde::__private::None;
496 for i in 0..22usize {
497 match i {
498 0usize => {
499 if _serde::__private::Option::is_some(&m_gains) {
500 return _serde::__private::Err(
501 <__A::Error as _serde::de::Error>::duplicate_field("gains"),
502 );
503 }
504 m_gains = _serde::__private::Some(
505 match __A::next_value::<hkbFootIkGains>(&mut __map) {
506 _serde::__private::Ok(__val) => __val,
507 _serde::__private::Err(__err) => {
508 return _serde::__private::Err(__err);
509 }
510 },
511 );
512 }
513 1usize => {
514 if _serde::__private::Option::is_some(&m_legs) {
515 return _serde::__private::Err(
516 <__A::Error as _serde::de::Error>::duplicate_field("legs"),
517 );
518 }
519 m_legs = _serde::__private::Some(
520 match __A::next_value::<
521 Vec<hkbFootIkModifierLeg>,
522 >(&mut __map) {
523 _serde::__private::Ok(__val) => __val,
524 _serde::__private::Err(__err) => {
525 return _serde::__private::Err(__err);
526 }
527 },
528 );
529 }
530 2usize => {
531 if _serde::__private::Option::is_some(
532 &m_raycastDistanceUp,
533 ) {
534 return _serde::__private::Err(
535 <__A::Error as _serde::de::Error>::duplicate_field(
536 "raycastDistanceUp",
537 ),
538 );
539 }
540 m_raycastDistanceUp = _serde::__private::Some(
541 match __A::next_value::<f32>(&mut __map) {
542 _serde::__private::Ok(__val) => __val,
543 _serde::__private::Err(__err) => {
544 return _serde::__private::Err(__err);
545 }
546 },
547 );
548 }
549 3usize => {
550 if _serde::__private::Option::is_some(
551 &m_raycastDistanceDown,
552 ) {
553 return _serde::__private::Err(
554 <__A::Error as _serde::de::Error>::duplicate_field(
555 "raycastDistanceDown",
556 ),
557 );
558 }
559 m_raycastDistanceDown = _serde::__private::Some(
560 match __A::next_value::<f32>(&mut __map) {
561 _serde::__private::Ok(__val) => __val,
562 _serde::__private::Err(__err) => {
563 return _serde::__private::Err(__err);
564 }
565 },
566 );
567 }
568 4usize => {
569 if _serde::__private::Option::is_some(
570 &m_originalGroundHeightMS,
571 ) {
572 return _serde::__private::Err(
573 <__A::Error as _serde::de::Error>::duplicate_field(
574 "originalGroundHeightMS",
575 ),
576 );
577 }
578 m_originalGroundHeightMS = _serde::__private::Some(
579 match __A::next_value::<f32>(&mut __map) {
580 _serde::__private::Ok(__val) => __val,
581 _serde::__private::Err(__err) => {
582 return _serde::__private::Err(__err);
583 }
584 },
585 );
586 }
587 5usize => {
588 if _serde::__private::Option::is_some(&m_errorOut) {
589 return _serde::__private::Err(
590 <__A::Error as _serde::de::Error>::duplicate_field(
591 "errorOut",
592 ),
593 );
594 }
595 m_errorOut = _serde::__private::Some(
596 match __A::next_value::<f32>(&mut __map) {
597 _serde::__private::Ok(__val) => __val,
598 _serde::__private::Err(__err) => {
599 return _serde::__private::Err(__err);
600 }
601 },
602 );
603 }
604 6usize => {
605 if _serde::__private::Option::is_some(
606 &m_errorOutTranslation,
607 ) {
608 return _serde::__private::Err(
609 <__A::Error as _serde::de::Error>::duplicate_field(
610 "errorOutTranslation",
611 ),
612 );
613 }
614 __A::pad(&mut __map, 8usize, 0usize)?;
615 m_errorOutTranslation = _serde::__private::Some(
616 match __A::next_value::<Vector4>(&mut __map) {
617 _serde::__private::Ok(__val) => __val,
618 _serde::__private::Err(__err) => {
619 return _serde::__private::Err(__err);
620 }
621 },
622 );
623 }
624 7usize => {
625 if _serde::__private::Option::is_some(
626 &m_alignWithGroundRotation,
627 ) {
628 return _serde::__private::Err(
629 <__A::Error as _serde::de::Error>::duplicate_field(
630 "alignWithGroundRotation",
631 ),
632 );
633 }
634 m_alignWithGroundRotation = _serde::__private::Some(
635 match __A::next_value::<Quaternion>(&mut __map) {
636 _serde::__private::Ok(__val) => __val,
637 _serde::__private::Err(__err) => {
638 return _serde::__private::Err(__err);
639 }
640 },
641 );
642 }
643 8usize => {
644 if _serde::__private::Option::is_some(&m_verticalOffset) {
645 return _serde::__private::Err(
646 <__A::Error as _serde::de::Error>::duplicate_field(
647 "verticalOffset",
648 ),
649 );
650 }
651 m_verticalOffset = _serde::__private::Some(
652 match __A::next_value::<f32>(&mut __map) {
653 _serde::__private::Ok(__val) => __val,
654 _serde::__private::Err(__err) => {
655 return _serde::__private::Err(__err);
656 }
657 },
658 );
659 }
660 9usize => {
661 if _serde::__private::Option::is_some(
662 &m_collisionFilterInfo,
663 ) {
664 return _serde::__private::Err(
665 <__A::Error as _serde::de::Error>::duplicate_field(
666 "collisionFilterInfo",
667 ),
668 );
669 }
670 m_collisionFilterInfo = _serde::__private::Some(
671 match __A::next_value::<u32>(&mut __map) {
672 _serde::__private::Ok(__val) => __val,
673 _serde::__private::Err(__err) => {
674 return _serde::__private::Err(__err);
675 }
676 },
677 );
678 }
679 10usize => {
680 if _serde::__private::Option::is_some(
681 &m_forwardAlignFraction,
682 ) {
683 return _serde::__private::Err(
684 <__A::Error as _serde::de::Error>::duplicate_field(
685 "forwardAlignFraction",
686 ),
687 );
688 }
689 m_forwardAlignFraction = _serde::__private::Some(
690 match __A::next_value::<f32>(&mut __map) {
691 _serde::__private::Ok(__val) => __val,
692 _serde::__private::Err(__err) => {
693 return _serde::__private::Err(__err);
694 }
695 },
696 );
697 }
698 11usize => {
699 if _serde::__private::Option::is_some(
700 &m_sidewaysAlignFraction,
701 ) {
702 return _serde::__private::Err(
703 <__A::Error as _serde::de::Error>::duplicate_field(
704 "sidewaysAlignFraction",
705 ),
706 );
707 }
708 m_sidewaysAlignFraction = _serde::__private::Some(
709 match __A::next_value::<f32>(&mut __map) {
710 _serde::__private::Ok(__val) => __val,
711 _serde::__private::Err(__err) => {
712 return _serde::__private::Err(__err);
713 }
714 },
715 );
716 }
717 12usize => {
718 if _serde::__private::Option::is_some(
719 &m_sidewaysSampleWidth,
720 ) {
721 return _serde::__private::Err(
722 <__A::Error as _serde::de::Error>::duplicate_field(
723 "sidewaysSampleWidth",
724 ),
725 );
726 }
727 m_sidewaysSampleWidth = _serde::__private::Some(
728 match __A::next_value::<f32>(&mut __map) {
729 _serde::__private::Ok(__val) => __val,
730 _serde::__private::Err(__err) => {
731 return _serde::__private::Err(__err);
732 }
733 },
734 );
735 }
736 13usize => {
737 if _serde::__private::Option::is_some(&m_useTrackData) {
738 return _serde::__private::Err(
739 <__A::Error as _serde::de::Error>::duplicate_field(
740 "useTrackData",
741 ),
742 );
743 }
744 m_useTrackData = _serde::__private::Some(
745 match __A::next_value::<bool>(&mut __map) {
746 _serde::__private::Ok(__val) => __val,
747 _serde::__private::Err(__err) => {
748 return _serde::__private::Err(__err);
749 }
750 },
751 );
752 }
753 14usize => {
754 if _serde::__private::Option::is_some(
755 &m_lockFeetWhenPlanted,
756 ) {
757 return _serde::__private::Err(
758 <__A::Error as _serde::de::Error>::duplicate_field(
759 "lockFeetWhenPlanted",
760 ),
761 );
762 }
763 m_lockFeetWhenPlanted = _serde::__private::Some(
764 match __A::next_value::<bool>(&mut __map) {
765 _serde::__private::Ok(__val) => __val,
766 _serde::__private::Err(__err) => {
767 return _serde::__private::Err(__err);
768 }
769 },
770 );
771 }
772 15usize => {
773 if _serde::__private::Option::is_some(
774 &m_useCharacterUpVector,
775 ) {
776 return _serde::__private::Err(
777 <__A::Error as _serde::de::Error>::duplicate_field(
778 "useCharacterUpVector",
779 ),
780 );
781 }
782 m_useCharacterUpVector = _serde::__private::Some(
783 match __A::next_value::<bool>(&mut __map) {
784 _serde::__private::Ok(__val) => __val,
785 _serde::__private::Err(__err) => {
786 return _serde::__private::Err(__err);
787 }
788 },
789 );
790 }
791 16usize => {
792 if _serde::__private::Option::is_some(&m_alignMode) {
793 return _serde::__private::Err(
794 <__A::Error as _serde::de::Error>::duplicate_field(
795 "alignMode",
796 ),
797 );
798 }
799 m_alignMode = _serde::__private::Some(
800 match __A::next_value::<AlignMode>(&mut __map) {
801 _serde::__private::Ok(__val) => __val,
802 _serde::__private::Err(__err) => {
803 return _serde::__private::Err(__err);
804 }
805 },
806 );
807 }
808 17usize => {
809 if _serde::__private::Option::is_some(&m_internalLegData) {
810 return _serde::__private::Err(
811 <__A::Error as _serde::de::Error>::duplicate_field(
812 "internalLegData",
813 ),
814 );
815 }
816 m_internalLegData = _serde::__private::Some(
817 match __A::next_value::<
818 Vec<hkbFootIkModifierInternalLegData>,
819 >(&mut __map) {
820 _serde::__private::Ok(__val) => __val,
821 _serde::__private::Err(__err) => {
822 return _serde::__private::Err(__err);
823 }
824 },
825 );
826 }
827 18usize => {
828 if _serde::__private::Option::is_some(
829 &m_prevIsFootIkEnabled,
830 ) {
831 return _serde::__private::Err(
832 <__A::Error as _serde::de::Error>::duplicate_field(
833 "prevIsFootIkEnabled",
834 ),
835 );
836 }
837 m_prevIsFootIkEnabled = _serde::__private::Some(
838 match __A::next_value::<f32>(&mut __map) {
839 _serde::__private::Ok(__val) => __val,
840 _serde::__private::Err(__err) => {
841 return _serde::__private::Err(__err);
842 }
843 },
844 );
845 }
846 19usize => {
847 if _serde::__private::Option::is_some(&m_isSetUp) {
848 return _serde::__private::Err(
849 <__A::Error as _serde::de::Error>::duplicate_field(
850 "isSetUp",
851 ),
852 );
853 }
854 m_isSetUp = _serde::__private::Some(
855 match __A::next_value::<bool>(&mut __map) {
856 _serde::__private::Ok(__val) => __val,
857 _serde::__private::Err(__err) => {
858 return _serde::__private::Err(__err);
859 }
860 },
861 );
862 }
863 20usize => {
864 if _serde::__private::Option::is_some(
865 &m_isGroundPositionValid,
866 ) {
867 return _serde::__private::Err(
868 <__A::Error as _serde::de::Error>::duplicate_field(
869 "isGroundPositionValid",
870 ),
871 );
872 }
873 m_isGroundPositionValid = _serde::__private::Some(
874 match __A::next_value::<bool>(&mut __map) {
875 _serde::__private::Ok(__val) => __val,
876 _serde::__private::Err(__err) => {
877 return _serde::__private::Err(__err);
878 }
879 },
880 );
881 }
882 21usize => {
883 if _serde::__private::Option::is_some(&m_timeStep) {
884 return _serde::__private::Err(
885 <__A::Error as _serde::de::Error>::duplicate_field(
886 "timeStep",
887 ),
888 );
889 }
890 __A::pad(&mut __map, 2usize, 2usize)?;
891 m_timeStep = _serde::__private::Some(
892 match __A::next_value::<f32>(&mut __map) {
893 _serde::__private::Ok(__val) => __val,
894 _serde::__private::Err(__err) => {
895 return _serde::__private::Err(__err);
896 }
897 },
898 );
899 }
900 _ => {}
901 }
902 }
903 __A::pad(&mut __map, 0usize, 12usize)?;
904 let m_gains = match m_gains {
905 _serde::__private::Some(__field) => __field,
906 _serde::__private::None => {
907 return _serde::__private::Err(
908 <__A::Error as _serde::de::Error>::missing_field("gains"),
909 );
910 }
911 };
912 let m_legs = match m_legs {
913 _serde::__private::Some(__field) => __field,
914 _serde::__private::None => {
915 return _serde::__private::Err(
916 <__A::Error as _serde::de::Error>::missing_field("legs"),
917 );
918 }
919 };
920 let m_raycastDistanceUp = match m_raycastDistanceUp {
921 _serde::__private::Some(__field) => __field,
922 _serde::__private::None => {
923 return _serde::__private::Err(
924 <__A::Error as _serde::de::Error>::missing_field(
925 "raycastDistanceUp",
926 ),
927 );
928 }
929 };
930 let m_raycastDistanceDown = match m_raycastDistanceDown {
931 _serde::__private::Some(__field) => __field,
932 _serde::__private::None => {
933 return _serde::__private::Err(
934 <__A::Error as _serde::de::Error>::missing_field(
935 "raycastDistanceDown",
936 ),
937 );
938 }
939 };
940 let m_originalGroundHeightMS = match m_originalGroundHeightMS {
941 _serde::__private::Some(__field) => __field,
942 _serde::__private::None => {
943 return _serde::__private::Err(
944 <__A::Error as _serde::de::Error>::missing_field(
945 "originalGroundHeightMS",
946 ),
947 );
948 }
949 };
950 let m_errorOut = match m_errorOut {
951 _serde::__private::Some(__field) => __field,
952 _serde::__private::None => {
953 return _serde::__private::Err(
954 <__A::Error as _serde::de::Error>::missing_field("errorOut"),
955 );
956 }
957 };
958 let m_errorOutTranslation = match m_errorOutTranslation {
959 _serde::__private::Some(__field) => __field,
960 _serde::__private::None => {
961 return _serde::__private::Err(
962 <__A::Error as _serde::de::Error>::missing_field(
963 "errorOutTranslation",
964 ),
965 );
966 }
967 };
968 let m_alignWithGroundRotation = match m_alignWithGroundRotation {
969 _serde::__private::Some(__field) => __field,
970 _serde::__private::None => {
971 return _serde::__private::Err(
972 <__A::Error as _serde::de::Error>::missing_field(
973 "alignWithGroundRotation",
974 ),
975 );
976 }
977 };
978 let m_verticalOffset = match m_verticalOffset {
979 _serde::__private::Some(__field) => __field,
980 _serde::__private::None => {
981 return _serde::__private::Err(
982 <__A::Error as _serde::de::Error>::missing_field(
983 "verticalOffset",
984 ),
985 );
986 }
987 };
988 let m_collisionFilterInfo = match m_collisionFilterInfo {
989 _serde::__private::Some(__field) => __field,
990 _serde::__private::None => {
991 return _serde::__private::Err(
992 <__A::Error as _serde::de::Error>::missing_field(
993 "collisionFilterInfo",
994 ),
995 );
996 }
997 };
998 let m_forwardAlignFraction = match m_forwardAlignFraction {
999 _serde::__private::Some(__field) => __field,
1000 _serde::__private::None => {
1001 return _serde::__private::Err(
1002 <__A::Error as _serde::de::Error>::missing_field(
1003 "forwardAlignFraction",
1004 ),
1005 );
1006 }
1007 };
1008 let m_sidewaysAlignFraction = match m_sidewaysAlignFraction {
1009 _serde::__private::Some(__field) => __field,
1010 _serde::__private::None => {
1011 return _serde::__private::Err(
1012 <__A::Error as _serde::de::Error>::missing_field(
1013 "sidewaysAlignFraction",
1014 ),
1015 );
1016 }
1017 };
1018 let m_sidewaysSampleWidth = match m_sidewaysSampleWidth {
1019 _serde::__private::Some(__field) => __field,
1020 _serde::__private::None => {
1021 return _serde::__private::Err(
1022 <__A::Error as _serde::de::Error>::missing_field(
1023 "sidewaysSampleWidth",
1024 ),
1025 );
1026 }
1027 };
1028 let m_useTrackData = match m_useTrackData {
1029 _serde::__private::Some(__field) => __field,
1030 _serde::__private::None => {
1031 return _serde::__private::Err(
1032 <__A::Error as _serde::de::Error>::missing_field(
1033 "useTrackData",
1034 ),
1035 );
1036 }
1037 };
1038 let m_lockFeetWhenPlanted = match m_lockFeetWhenPlanted {
1039 _serde::__private::Some(__field) => __field,
1040 _serde::__private::None => {
1041 return _serde::__private::Err(
1042 <__A::Error as _serde::de::Error>::missing_field(
1043 "lockFeetWhenPlanted",
1044 ),
1045 );
1046 }
1047 };
1048 let m_useCharacterUpVector = match m_useCharacterUpVector {
1049 _serde::__private::Some(__field) => __field,
1050 _serde::__private::None => {
1051 return _serde::__private::Err(
1052 <__A::Error as _serde::de::Error>::missing_field(
1053 "useCharacterUpVector",
1054 ),
1055 );
1056 }
1057 };
1058 let m_alignMode = match m_alignMode {
1059 _serde::__private::Some(__field) => __field,
1060 _serde::__private::None => {
1061 return _serde::__private::Err(
1062 <__A::Error as _serde::de::Error>::missing_field(
1063 "alignMode",
1064 ),
1065 );
1066 }
1067 };
1068 let m_internalLegData = match m_internalLegData {
1069 _serde::__private::Some(__field) => __field,
1070 _serde::__private::None => {
1071 return _serde::__private::Err(
1072 <__A::Error as _serde::de::Error>::missing_field(
1073 "internalLegData",
1074 ),
1075 );
1076 }
1077 };
1078 let m_prevIsFootIkEnabled = match m_prevIsFootIkEnabled {
1079 _serde::__private::Some(__field) => __field,
1080 _serde::__private::None => {
1081 return _serde::__private::Err(
1082 <__A::Error as _serde::de::Error>::missing_field(
1083 "prevIsFootIkEnabled",
1084 ),
1085 );
1086 }
1087 };
1088 let m_isSetUp = match m_isSetUp {
1089 _serde::__private::Some(__field) => __field,
1090 _serde::__private::None => {
1091 return _serde::__private::Err(
1092 <__A::Error as _serde::de::Error>::missing_field("isSetUp"),
1093 );
1094 }
1095 };
1096 let m_isGroundPositionValid = match m_isGroundPositionValid {
1097 _serde::__private::Some(__field) => __field,
1098 _serde::__private::None => {
1099 return _serde::__private::Err(
1100 <__A::Error as _serde::de::Error>::missing_field(
1101 "isGroundPositionValid",
1102 ),
1103 );
1104 }
1105 };
1106 let m_timeStep = match m_timeStep {
1107 _serde::__private::Some(__field) => __field,
1108 _serde::__private::None => {
1109 return _serde::__private::Err(
1110 <__A::Error as _serde::de::Error>::missing_field("timeStep"),
1111 );
1112 }
1113 };
1114 _serde::__private::Ok(hkbFootIkModifier {
1115 __ptr,
1116 parent,
1117 m_gains,
1118 m_legs,
1119 m_raycastDistanceUp,
1120 m_raycastDistanceDown,
1121 m_originalGroundHeightMS,
1122 m_errorOut,
1123 m_errorOutTranslation,
1124 m_alignWithGroundRotation,
1125 m_verticalOffset,
1126 m_collisionFilterInfo,
1127 m_forwardAlignFraction,
1128 m_sidewaysAlignFraction,
1129 m_sidewaysSampleWidth,
1130 m_useTrackData,
1131 m_lockFeetWhenPlanted,
1132 m_useCharacterUpVector,
1133 m_alignMode,
1134 m_internalLegData,
1135 m_prevIsFootIkEnabled,
1136 m_isSetUp,
1137 m_isGroundPositionValid,
1138 m_timeStep,
1139 })
1140 }
1141 #[allow(clippy::manual_unwrap_or_default)]
1142 fn visit_struct<__A>(
1143 self,
1144 mut __map: __A,
1145 ) -> _serde::__private::Result<Self::Value, __A::Error>
1146 where
1147 __A: _serde::de::MapAccess<'de>,
1148 {
1149 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
1150 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1151 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1152 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
1153 let mut m_gains: _serde::__private::Option<hkbFootIkGains> = _serde::__private::None;
1154 let mut m_legs: _serde::__private::Option<
1155 Vec<hkbFootIkModifierLeg>,
1156 > = _serde::__private::None;
1157 let mut m_raycastDistanceUp: _serde::__private::Option<f32> = _serde::__private::None;
1158 let mut m_raycastDistanceDown: _serde::__private::Option<f32> = _serde::__private::None;
1159 let mut m_originalGroundHeightMS: _serde::__private::Option<f32> = _serde::__private::None;
1160 let mut m_errorOut: _serde::__private::Option<f32> = _serde::__private::None;
1161 let mut m_errorOutTranslation: _serde::__private::Option<Vector4> = _serde::__private::None;
1162 let mut m_alignWithGroundRotation: _serde::__private::Option<
1163 Quaternion,
1164 > = _serde::__private::None;
1165 let mut m_verticalOffset: _serde::__private::Option<f32> = _serde::__private::None;
1166 let mut m_collisionFilterInfo: _serde::__private::Option<u32> = _serde::__private::None;
1167 let mut m_forwardAlignFraction: _serde::__private::Option<f32> = _serde::__private::None;
1168 let mut m_sidewaysAlignFraction: _serde::__private::Option<f32> = _serde::__private::None;
1169 let mut m_sidewaysSampleWidth: _serde::__private::Option<f32> = _serde::__private::None;
1170 let mut m_useTrackData: _serde::__private::Option<bool> = _serde::__private::None;
1171 let mut m_lockFeetWhenPlanted: _serde::__private::Option<bool> = _serde::__private::None;
1172 let mut m_useCharacterUpVector: _serde::__private::Option<bool> = _serde::__private::None;
1173 let mut m_alignMode: _serde::__private::Option<AlignMode> = _serde::__private::None;
1174 while let _serde::__private::Some(__key) = {
1175 __A::next_key::<__Field>(&mut __map)?
1176 } {
1177 match __key {
1178 __Field::m_variableBindingSet => {
1179 #[cfg(
1180 any(feature = "strict", feature = "ignore_duplicates")
1181 )]
1182 if _serde::__private::Option::is_some(
1183 &m_variableBindingSet,
1184 ) {
1185 #[cfg(feature = "ignore_duplicates")]
1186 {
1187 __A::skip_value(&mut __map)?;
1188 continue;
1189 }
1190 #[cfg(feature = "strict")]
1191 return _serde::__private::Err(
1192 <__A::Error as _serde::de::Error>::duplicate_field(
1193 "variableBindingSet",
1194 ),
1195 );
1196 }
1197 m_variableBindingSet = _serde::__private::Some(
1198 match __A::next_value::<Pointer>(&mut __map) {
1199 _serde::__private::Ok(__val) => __val,
1200 _serde::__private::Err(__err) => {
1201 return _serde::__private::Err(__err);
1202 }
1203 },
1204 );
1205 }
1206 __Field::m_userData => {
1207 #[cfg(
1208 any(feature = "strict", feature = "ignore_duplicates")
1209 )]
1210 if _serde::__private::Option::is_some(&m_userData) {
1211 #[cfg(feature = "ignore_duplicates")]
1212 {
1213 __A::skip_value(&mut __map)?;
1214 continue;
1215 }
1216 #[cfg(feature = "strict")]
1217 return _serde::__private::Err(
1218 <__A::Error as _serde::de::Error>::duplicate_field(
1219 "userData",
1220 ),
1221 );
1222 }
1223 m_userData = _serde::__private::Some(
1224 match __A::next_value::<Ulong>(&mut __map) {
1225 _serde::__private::Ok(__val) => __val,
1226 _serde::__private::Err(__err) => {
1227 return _serde::__private::Err(__err);
1228 }
1229 },
1230 );
1231 }
1232 __Field::m_name => {
1233 #[cfg(
1234 any(feature = "strict", feature = "ignore_duplicates")
1235 )]
1236 if _serde::__private::Option::is_some(&m_name) {
1237 #[cfg(feature = "ignore_duplicates")]
1238 {
1239 __A::skip_value(&mut __map)?;
1240 continue;
1241 }
1242 #[cfg(feature = "strict")]
1243 return _serde::__private::Err(
1244 <__A::Error as _serde::de::Error>::duplicate_field("name"),
1245 );
1246 }
1247 m_name = _serde::__private::Some(
1248 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1249 _serde::__private::Ok(__val) => __val,
1250 _serde::__private::Err(__err) => {
1251 return _serde::__private::Err(__err);
1252 }
1253 },
1254 );
1255 }
1256 __Field::m_enable => {
1257 #[cfg(
1258 any(feature = "strict", feature = "ignore_duplicates")
1259 )]
1260 if _serde::__private::Option::is_some(&m_enable) {
1261 #[cfg(feature = "ignore_duplicates")]
1262 {
1263 __A::skip_value(&mut __map)?;
1264 continue;
1265 }
1266 #[cfg(feature = "strict")]
1267 return _serde::__private::Err(
1268 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
1269 );
1270 }
1271 m_enable = _serde::__private::Some(
1272 match __A::next_value::<bool>(&mut __map) {
1273 _serde::__private::Ok(__val) => __val,
1274 _serde::__private::Err(__err) => {
1275 return _serde::__private::Err(__err);
1276 }
1277 },
1278 );
1279 }
1280 __Field::m_gains => {
1281 #[cfg(
1282 any(feature = "strict", feature = "ignore_duplicates")
1283 )]
1284 if _serde::__private::Option::is_some(&m_gains) {
1285 #[cfg(feature = "ignore_duplicates")]
1286 {
1287 __A::skip_value(&mut __map)?;
1288 continue;
1289 }
1290 #[cfg(feature = "strict")]
1291 return _serde::__private::Err(
1292 <__A::Error as _serde::de::Error>::duplicate_field("gains"),
1293 );
1294 }
1295 m_gains = _serde::__private::Some(
1296 match __A::next_value::<hkbFootIkGains>(&mut __map) {
1297 _serde::__private::Ok(__val) => __val,
1298 _serde::__private::Err(__err) => {
1299 return _serde::__private::Err(__err);
1300 }
1301 },
1302 );
1303 }
1304 __Field::m_legs => {
1305 #[cfg(
1306 any(feature = "strict", feature = "ignore_duplicates")
1307 )]
1308 if _serde::__private::Option::is_some(&m_legs) {
1309 #[cfg(feature = "ignore_duplicates")]
1310 {
1311 __A::skip_value(&mut __map)?;
1312 continue;
1313 }
1314 #[cfg(feature = "strict")]
1315 return _serde::__private::Err(
1316 <__A::Error as _serde::de::Error>::duplicate_field("legs"),
1317 );
1318 }
1319 m_legs = _serde::__private::Some(
1320 match __A::next_value::<
1321 Vec<hkbFootIkModifierLeg>,
1322 >(&mut __map) {
1323 _serde::__private::Ok(__val) => __val,
1324 _serde::__private::Err(__err) => {
1325 return _serde::__private::Err(__err);
1326 }
1327 },
1328 );
1329 }
1330 __Field::m_raycastDistanceUp => {
1331 #[cfg(
1332 any(feature = "strict", feature = "ignore_duplicates")
1333 )]
1334 if _serde::__private::Option::is_some(
1335 &m_raycastDistanceUp,
1336 ) {
1337 #[cfg(feature = "ignore_duplicates")]
1338 {
1339 __A::skip_value(&mut __map)?;
1340 continue;
1341 }
1342 #[cfg(feature = "strict")]
1343 return _serde::__private::Err(
1344 <__A::Error as _serde::de::Error>::duplicate_field(
1345 "raycastDistanceUp",
1346 ),
1347 );
1348 }
1349 m_raycastDistanceUp = _serde::__private::Some(
1350 match __A::next_value::<f32>(&mut __map) {
1351 _serde::__private::Ok(__val) => __val,
1352 _serde::__private::Err(__err) => {
1353 return _serde::__private::Err(__err);
1354 }
1355 },
1356 );
1357 }
1358 __Field::m_raycastDistanceDown => {
1359 #[cfg(
1360 any(feature = "strict", feature = "ignore_duplicates")
1361 )]
1362 if _serde::__private::Option::is_some(
1363 &m_raycastDistanceDown,
1364 ) {
1365 #[cfg(feature = "ignore_duplicates")]
1366 {
1367 __A::skip_value(&mut __map)?;
1368 continue;
1369 }
1370 #[cfg(feature = "strict")]
1371 return _serde::__private::Err(
1372 <__A::Error as _serde::de::Error>::duplicate_field(
1373 "raycastDistanceDown",
1374 ),
1375 );
1376 }
1377 m_raycastDistanceDown = _serde::__private::Some(
1378 match __A::next_value::<f32>(&mut __map) {
1379 _serde::__private::Ok(__val) => __val,
1380 _serde::__private::Err(__err) => {
1381 return _serde::__private::Err(__err);
1382 }
1383 },
1384 );
1385 }
1386 __Field::m_originalGroundHeightMS => {
1387 #[cfg(
1388 any(feature = "strict", feature = "ignore_duplicates")
1389 )]
1390 if _serde::__private::Option::is_some(
1391 &m_originalGroundHeightMS,
1392 ) {
1393 #[cfg(feature = "ignore_duplicates")]
1394 {
1395 __A::skip_value(&mut __map)?;
1396 continue;
1397 }
1398 #[cfg(feature = "strict")]
1399 return _serde::__private::Err(
1400 <__A::Error as _serde::de::Error>::duplicate_field(
1401 "originalGroundHeightMS",
1402 ),
1403 );
1404 }
1405 m_originalGroundHeightMS = _serde::__private::Some(
1406 match __A::next_value::<f32>(&mut __map) {
1407 _serde::__private::Ok(__val) => __val,
1408 _serde::__private::Err(__err) => {
1409 return _serde::__private::Err(__err);
1410 }
1411 },
1412 );
1413 }
1414 __Field::m_errorOut => {
1415 #[cfg(
1416 any(feature = "strict", feature = "ignore_duplicates")
1417 )]
1418 if _serde::__private::Option::is_some(&m_errorOut) {
1419 #[cfg(feature = "ignore_duplicates")]
1420 {
1421 __A::skip_value(&mut __map)?;
1422 continue;
1423 }
1424 #[cfg(feature = "strict")]
1425 return _serde::__private::Err(
1426 <__A::Error as _serde::de::Error>::duplicate_field(
1427 "errorOut",
1428 ),
1429 );
1430 }
1431 m_errorOut = _serde::__private::Some(
1432 match __A::next_value::<f32>(&mut __map) {
1433 _serde::__private::Ok(__val) => __val,
1434 _serde::__private::Err(__err) => {
1435 return _serde::__private::Err(__err);
1436 }
1437 },
1438 );
1439 }
1440 __Field::m_errorOutTranslation => {
1441 #[cfg(
1442 any(feature = "strict", feature = "ignore_duplicates")
1443 )]
1444 if _serde::__private::Option::is_some(
1445 &m_errorOutTranslation,
1446 ) {
1447 #[cfg(feature = "ignore_duplicates")]
1448 {
1449 __A::skip_value(&mut __map)?;
1450 continue;
1451 }
1452 #[cfg(feature = "strict")]
1453 return _serde::__private::Err(
1454 <__A::Error as _serde::de::Error>::duplicate_field(
1455 "errorOutTranslation",
1456 ),
1457 );
1458 }
1459 m_errorOutTranslation = _serde::__private::Some(
1460 match __A::next_value::<Vector4>(&mut __map) {
1461 _serde::__private::Ok(__val) => __val,
1462 _serde::__private::Err(__err) => {
1463 return _serde::__private::Err(__err);
1464 }
1465 },
1466 );
1467 }
1468 __Field::m_alignWithGroundRotation => {
1469 #[cfg(
1470 any(feature = "strict", feature = "ignore_duplicates")
1471 )]
1472 if _serde::__private::Option::is_some(
1473 &m_alignWithGroundRotation,
1474 ) {
1475 #[cfg(feature = "ignore_duplicates")]
1476 {
1477 __A::skip_value(&mut __map)?;
1478 continue;
1479 }
1480 #[cfg(feature = "strict")]
1481 return _serde::__private::Err(
1482 <__A::Error as _serde::de::Error>::duplicate_field(
1483 "alignWithGroundRotation",
1484 ),
1485 );
1486 }
1487 m_alignWithGroundRotation = _serde::__private::Some(
1488 match __A::next_value::<Quaternion>(&mut __map) {
1489 _serde::__private::Ok(__val) => __val,
1490 _serde::__private::Err(__err) => {
1491 return _serde::__private::Err(__err);
1492 }
1493 },
1494 );
1495 }
1496 __Field::m_verticalOffset => {
1497 #[cfg(
1498 any(feature = "strict", feature = "ignore_duplicates")
1499 )]
1500 if _serde::__private::Option::is_some(&m_verticalOffset) {
1501 #[cfg(feature = "ignore_duplicates")]
1502 {
1503 __A::skip_value(&mut __map)?;
1504 continue;
1505 }
1506 #[cfg(feature = "strict")]
1507 return _serde::__private::Err(
1508 <__A::Error as _serde::de::Error>::duplicate_field(
1509 "verticalOffset",
1510 ),
1511 );
1512 }
1513 m_verticalOffset = _serde::__private::Some(
1514 match __A::next_value::<f32>(&mut __map) {
1515 _serde::__private::Ok(__val) => __val,
1516 _serde::__private::Err(__err) => {
1517 return _serde::__private::Err(__err);
1518 }
1519 },
1520 );
1521 }
1522 __Field::m_collisionFilterInfo => {
1523 #[cfg(
1524 any(feature = "strict", feature = "ignore_duplicates")
1525 )]
1526 if _serde::__private::Option::is_some(
1527 &m_collisionFilterInfo,
1528 ) {
1529 #[cfg(feature = "ignore_duplicates")]
1530 {
1531 __A::skip_value(&mut __map)?;
1532 continue;
1533 }
1534 #[cfg(feature = "strict")]
1535 return _serde::__private::Err(
1536 <__A::Error as _serde::de::Error>::duplicate_field(
1537 "collisionFilterInfo",
1538 ),
1539 );
1540 }
1541 m_collisionFilterInfo = _serde::__private::Some(
1542 match __A::next_value::<u32>(&mut __map) {
1543 _serde::__private::Ok(__val) => __val,
1544 _serde::__private::Err(__err) => {
1545 return _serde::__private::Err(__err);
1546 }
1547 },
1548 );
1549 }
1550 __Field::m_forwardAlignFraction => {
1551 #[cfg(
1552 any(feature = "strict", feature = "ignore_duplicates")
1553 )]
1554 if _serde::__private::Option::is_some(
1555 &m_forwardAlignFraction,
1556 ) {
1557 #[cfg(feature = "ignore_duplicates")]
1558 {
1559 __A::skip_value(&mut __map)?;
1560 continue;
1561 }
1562 #[cfg(feature = "strict")]
1563 return _serde::__private::Err(
1564 <__A::Error as _serde::de::Error>::duplicate_field(
1565 "forwardAlignFraction",
1566 ),
1567 );
1568 }
1569 m_forwardAlignFraction = _serde::__private::Some(
1570 match __A::next_value::<f32>(&mut __map) {
1571 _serde::__private::Ok(__val) => __val,
1572 _serde::__private::Err(__err) => {
1573 return _serde::__private::Err(__err);
1574 }
1575 },
1576 );
1577 }
1578 __Field::m_sidewaysAlignFraction => {
1579 #[cfg(
1580 any(feature = "strict", feature = "ignore_duplicates")
1581 )]
1582 if _serde::__private::Option::is_some(
1583 &m_sidewaysAlignFraction,
1584 ) {
1585 #[cfg(feature = "ignore_duplicates")]
1586 {
1587 __A::skip_value(&mut __map)?;
1588 continue;
1589 }
1590 #[cfg(feature = "strict")]
1591 return _serde::__private::Err(
1592 <__A::Error as _serde::de::Error>::duplicate_field(
1593 "sidewaysAlignFraction",
1594 ),
1595 );
1596 }
1597 m_sidewaysAlignFraction = _serde::__private::Some(
1598 match __A::next_value::<f32>(&mut __map) {
1599 _serde::__private::Ok(__val) => __val,
1600 _serde::__private::Err(__err) => {
1601 return _serde::__private::Err(__err);
1602 }
1603 },
1604 );
1605 }
1606 __Field::m_sidewaysSampleWidth => {
1607 #[cfg(
1608 any(feature = "strict", feature = "ignore_duplicates")
1609 )]
1610 if _serde::__private::Option::is_some(
1611 &m_sidewaysSampleWidth,
1612 ) {
1613 #[cfg(feature = "ignore_duplicates")]
1614 {
1615 __A::skip_value(&mut __map)?;
1616 continue;
1617 }
1618 #[cfg(feature = "strict")]
1619 return _serde::__private::Err(
1620 <__A::Error as _serde::de::Error>::duplicate_field(
1621 "sidewaysSampleWidth",
1622 ),
1623 );
1624 }
1625 m_sidewaysSampleWidth = _serde::__private::Some(
1626 match __A::next_value::<f32>(&mut __map) {
1627 _serde::__private::Ok(__val) => __val,
1628 _serde::__private::Err(__err) => {
1629 return _serde::__private::Err(__err);
1630 }
1631 },
1632 );
1633 }
1634 __Field::m_useTrackData => {
1635 #[cfg(
1636 any(feature = "strict", feature = "ignore_duplicates")
1637 )]
1638 if _serde::__private::Option::is_some(&m_useTrackData) {
1639 #[cfg(feature = "ignore_duplicates")]
1640 {
1641 __A::skip_value(&mut __map)?;
1642 continue;
1643 }
1644 #[cfg(feature = "strict")]
1645 return _serde::__private::Err(
1646 <__A::Error as _serde::de::Error>::duplicate_field(
1647 "useTrackData",
1648 ),
1649 );
1650 }
1651 m_useTrackData = _serde::__private::Some(
1652 match __A::next_value::<bool>(&mut __map) {
1653 _serde::__private::Ok(__val) => __val,
1654 _serde::__private::Err(__err) => {
1655 return _serde::__private::Err(__err);
1656 }
1657 },
1658 );
1659 }
1660 __Field::m_lockFeetWhenPlanted => {
1661 #[cfg(
1662 any(feature = "strict", feature = "ignore_duplicates")
1663 )]
1664 if _serde::__private::Option::is_some(
1665 &m_lockFeetWhenPlanted,
1666 ) {
1667 #[cfg(feature = "ignore_duplicates")]
1668 {
1669 __A::skip_value(&mut __map)?;
1670 continue;
1671 }
1672 #[cfg(feature = "strict")]
1673 return _serde::__private::Err(
1674 <__A::Error as _serde::de::Error>::duplicate_field(
1675 "lockFeetWhenPlanted",
1676 ),
1677 );
1678 }
1679 m_lockFeetWhenPlanted = _serde::__private::Some(
1680 match __A::next_value::<bool>(&mut __map) {
1681 _serde::__private::Ok(__val) => __val,
1682 _serde::__private::Err(__err) => {
1683 return _serde::__private::Err(__err);
1684 }
1685 },
1686 );
1687 }
1688 __Field::m_useCharacterUpVector => {
1689 #[cfg(
1690 any(feature = "strict", feature = "ignore_duplicates")
1691 )]
1692 if _serde::__private::Option::is_some(
1693 &m_useCharacterUpVector,
1694 ) {
1695 #[cfg(feature = "ignore_duplicates")]
1696 {
1697 __A::skip_value(&mut __map)?;
1698 continue;
1699 }
1700 #[cfg(feature = "strict")]
1701 return _serde::__private::Err(
1702 <__A::Error as _serde::de::Error>::duplicate_field(
1703 "useCharacterUpVector",
1704 ),
1705 );
1706 }
1707 m_useCharacterUpVector = _serde::__private::Some(
1708 match __A::next_value::<bool>(&mut __map) {
1709 _serde::__private::Ok(__val) => __val,
1710 _serde::__private::Err(__err) => {
1711 return _serde::__private::Err(__err);
1712 }
1713 },
1714 );
1715 }
1716 __Field::m_alignMode => {
1717 #[cfg(
1718 any(feature = "strict", feature = "ignore_duplicates")
1719 )]
1720 if _serde::__private::Option::is_some(&m_alignMode) {
1721 #[cfg(feature = "ignore_duplicates")]
1722 {
1723 __A::skip_value(&mut __map)?;
1724 continue;
1725 }
1726 #[cfg(feature = "strict")]
1727 return _serde::__private::Err(
1728 <__A::Error as _serde::de::Error>::duplicate_field(
1729 "alignMode",
1730 ),
1731 );
1732 }
1733 m_alignMode = _serde::__private::Some(
1734 match __A::next_value::<AlignMode>(&mut __map) {
1735 _serde::__private::Ok(__val) => __val,
1736 _serde::__private::Err(__err) => {
1737 return _serde::__private::Err(__err);
1738 }
1739 },
1740 );
1741 }
1742 _ => __A::skip_value(&mut __map)?,
1743 }
1744 }
1745 let m_variableBindingSet = match m_variableBindingSet {
1746 _serde::__private::Some(__field) => __field,
1747 _serde::__private::None => {
1748 #[cfg(feature = "strict")]
1749 return _serde::__private::Err(
1750 <__A::Error as _serde::de::Error>::missing_field(
1751 "variableBindingSet",
1752 ),
1753 );
1754 #[cfg(not(feature = "strict"))] Default::default()
1755 }
1756 };
1757 let m_userData = match m_userData {
1758 _serde::__private::Some(__field) => __field,
1759 _serde::__private::None => {
1760 #[cfg(feature = "strict")]
1761 return _serde::__private::Err(
1762 <__A::Error as _serde::de::Error>::missing_field("userData"),
1763 );
1764 #[cfg(not(feature = "strict"))] Default::default()
1765 }
1766 };
1767 let m_name = match m_name {
1768 _serde::__private::Some(__field) => __field,
1769 _serde::__private::None => {
1770 #[cfg(feature = "strict")]
1771 return _serde::__private::Err(
1772 <__A::Error as _serde::de::Error>::missing_field("name"),
1773 );
1774 #[cfg(not(feature = "strict"))] Default::default()
1775 }
1776 };
1777 let m_enable = match m_enable {
1778 _serde::__private::Some(__field) => __field,
1779 _serde::__private::None => {
1780 #[cfg(feature = "strict")]
1781 return _serde::__private::Err(
1782 <__A::Error as _serde::de::Error>::missing_field("enable"),
1783 );
1784 #[cfg(not(feature = "strict"))] Default::default()
1785 }
1786 };
1787 let m_gains = match m_gains {
1788 _serde::__private::Some(__field) => __field,
1789 _serde::__private::None => {
1790 #[cfg(feature = "strict")]
1791 return _serde::__private::Err(
1792 <__A::Error as _serde::de::Error>::missing_field("gains"),
1793 );
1794 #[cfg(not(feature = "strict"))] Default::default()
1795 }
1796 };
1797 let m_legs = match m_legs {
1798 _serde::__private::Some(__field) => __field,
1799 _serde::__private::None => {
1800 #[cfg(feature = "strict")]
1801 return _serde::__private::Err(
1802 <__A::Error as _serde::de::Error>::missing_field("legs"),
1803 );
1804 #[cfg(not(feature = "strict"))] Default::default()
1805 }
1806 };
1807 let m_raycastDistanceUp = match m_raycastDistanceUp {
1808 _serde::__private::Some(__field) => __field,
1809 _serde::__private::None => {
1810 #[cfg(feature = "strict")]
1811 return _serde::__private::Err(
1812 <__A::Error as _serde::de::Error>::missing_field(
1813 "raycastDistanceUp",
1814 ),
1815 );
1816 #[cfg(not(feature = "strict"))] Default::default()
1817 }
1818 };
1819 let m_raycastDistanceDown = match m_raycastDistanceDown {
1820 _serde::__private::Some(__field) => __field,
1821 _serde::__private::None => {
1822 #[cfg(feature = "strict")]
1823 return _serde::__private::Err(
1824 <__A::Error as _serde::de::Error>::missing_field(
1825 "raycastDistanceDown",
1826 ),
1827 );
1828 #[cfg(not(feature = "strict"))] Default::default()
1829 }
1830 };
1831 let m_originalGroundHeightMS = match m_originalGroundHeightMS {
1832 _serde::__private::Some(__field) => __field,
1833 _serde::__private::None => {
1834 #[cfg(feature = "strict")]
1835 return _serde::__private::Err(
1836 <__A::Error as _serde::de::Error>::missing_field(
1837 "originalGroundHeightMS",
1838 ),
1839 );
1840 #[cfg(not(feature = "strict"))] Default::default()
1841 }
1842 };
1843 let m_errorOut = match m_errorOut {
1844 _serde::__private::Some(__field) => __field,
1845 _serde::__private::None => {
1846 #[cfg(feature = "strict")]
1847 return _serde::__private::Err(
1848 <__A::Error as _serde::de::Error>::missing_field("errorOut"),
1849 );
1850 #[cfg(not(feature = "strict"))] Default::default()
1851 }
1852 };
1853 let m_errorOutTranslation = match m_errorOutTranslation {
1854 _serde::__private::Some(__field) => __field,
1855 _serde::__private::None => {
1856 #[cfg(feature = "strict")]
1857 return _serde::__private::Err(
1858 <__A::Error as _serde::de::Error>::missing_field(
1859 "errorOutTranslation",
1860 ),
1861 );
1862 #[cfg(not(feature = "strict"))] Default::default()
1863 }
1864 };
1865 let m_alignWithGroundRotation = match m_alignWithGroundRotation {
1866 _serde::__private::Some(__field) => __field,
1867 _serde::__private::None => {
1868 #[cfg(feature = "strict")]
1869 return _serde::__private::Err(
1870 <__A::Error as _serde::de::Error>::missing_field(
1871 "alignWithGroundRotation",
1872 ),
1873 );
1874 #[cfg(not(feature = "strict"))] Default::default()
1875 }
1876 };
1877 let m_verticalOffset = match m_verticalOffset {
1878 _serde::__private::Some(__field) => __field,
1879 _serde::__private::None => {
1880 #[cfg(feature = "strict")]
1881 return _serde::__private::Err(
1882 <__A::Error as _serde::de::Error>::missing_field(
1883 "verticalOffset",
1884 ),
1885 );
1886 #[cfg(not(feature = "strict"))] Default::default()
1887 }
1888 };
1889 let m_collisionFilterInfo = match m_collisionFilterInfo {
1890 _serde::__private::Some(__field) => __field,
1891 _serde::__private::None => {
1892 #[cfg(feature = "strict")]
1893 return _serde::__private::Err(
1894 <__A::Error as _serde::de::Error>::missing_field(
1895 "collisionFilterInfo",
1896 ),
1897 );
1898 #[cfg(not(feature = "strict"))] Default::default()
1899 }
1900 };
1901 let m_forwardAlignFraction = match m_forwardAlignFraction {
1902 _serde::__private::Some(__field) => __field,
1903 _serde::__private::None => {
1904 #[cfg(feature = "strict")]
1905 return _serde::__private::Err(
1906 <__A::Error as _serde::de::Error>::missing_field(
1907 "forwardAlignFraction",
1908 ),
1909 );
1910 #[cfg(not(feature = "strict"))] Default::default()
1911 }
1912 };
1913 let m_sidewaysAlignFraction = match m_sidewaysAlignFraction {
1914 _serde::__private::Some(__field) => __field,
1915 _serde::__private::None => {
1916 #[cfg(feature = "strict")]
1917 return _serde::__private::Err(
1918 <__A::Error as _serde::de::Error>::missing_field(
1919 "sidewaysAlignFraction",
1920 ),
1921 );
1922 #[cfg(not(feature = "strict"))] Default::default()
1923 }
1924 };
1925 let m_sidewaysSampleWidth = match m_sidewaysSampleWidth {
1926 _serde::__private::Some(__field) => __field,
1927 _serde::__private::None => {
1928 #[cfg(feature = "strict")]
1929 return _serde::__private::Err(
1930 <__A::Error as _serde::de::Error>::missing_field(
1931 "sidewaysSampleWidth",
1932 ),
1933 );
1934 #[cfg(not(feature = "strict"))] Default::default()
1935 }
1936 };
1937 let m_useTrackData = match m_useTrackData {
1938 _serde::__private::Some(__field) => __field,
1939 _serde::__private::None => {
1940 #[cfg(feature = "strict")]
1941 return _serde::__private::Err(
1942 <__A::Error as _serde::de::Error>::missing_field(
1943 "useTrackData",
1944 ),
1945 );
1946 #[cfg(not(feature = "strict"))] Default::default()
1947 }
1948 };
1949 let m_lockFeetWhenPlanted = match m_lockFeetWhenPlanted {
1950 _serde::__private::Some(__field) => __field,
1951 _serde::__private::None => {
1952 #[cfg(feature = "strict")]
1953 return _serde::__private::Err(
1954 <__A::Error as _serde::de::Error>::missing_field(
1955 "lockFeetWhenPlanted",
1956 ),
1957 );
1958 #[cfg(not(feature = "strict"))] Default::default()
1959 }
1960 };
1961 let m_useCharacterUpVector = match m_useCharacterUpVector {
1962 _serde::__private::Some(__field) => __field,
1963 _serde::__private::None => {
1964 #[cfg(feature = "strict")]
1965 return _serde::__private::Err(
1966 <__A::Error as _serde::de::Error>::missing_field(
1967 "useCharacterUpVector",
1968 ),
1969 );
1970 #[cfg(not(feature = "strict"))] Default::default()
1971 }
1972 };
1973 let m_alignMode = match m_alignMode {
1974 _serde::__private::Some(__field) => __field,
1975 _serde::__private::None => {
1976 #[cfg(feature = "strict")]
1977 return _serde::__private::Err(
1978 <__A::Error as _serde::de::Error>::missing_field(
1979 "alignMode",
1980 ),
1981 );
1982 #[cfg(not(feature = "strict"))] Default::default()
1983 }
1984 };
1985 let __ptr = None;
1986 let parent = hkBaseObject { __ptr };
1987 let parent = hkReferencedObject {
1988 __ptr,
1989 parent,
1990 ..Default::default()
1991 };
1992 let parent = hkbBindable {
1993 __ptr,
1994 parent,
1995 m_variableBindingSet,
1996 ..Default::default()
1997 };
1998 let parent = hkbNode {
1999 __ptr,
2000 parent,
2001 m_userData,
2002 m_name,
2003 ..Default::default()
2004 };
2005 let parent = hkbModifier {
2006 __ptr,
2007 parent,
2008 m_enable,
2009 ..Default::default()
2010 };
2011 let __ptr = __A::class_ptr(&mut __map);
2012 _serde::__private::Ok(hkbFootIkModifier {
2013 __ptr,
2014 parent,
2015 m_gains,
2016 m_legs,
2017 m_raycastDistanceUp,
2018 m_raycastDistanceDown,
2019 m_originalGroundHeightMS,
2020 m_errorOut,
2021 m_errorOutTranslation,
2022 m_alignWithGroundRotation,
2023 m_verticalOffset,
2024 m_collisionFilterInfo,
2025 m_forwardAlignFraction,
2026 m_sidewaysAlignFraction,
2027 m_sidewaysSampleWidth,
2028 m_useTrackData,
2029 m_lockFeetWhenPlanted,
2030 m_useCharacterUpVector,
2031 m_alignMode,
2032 ..Default::default()
2033 })
2034 }
2035 }
2036 const FIELDS: &[&str] = &[
2037 "gains",
2038 "legs",
2039 "raycastDistanceUp",
2040 "raycastDistanceDown",
2041 "originalGroundHeightMS",
2042 "errorOut",
2043 "errorOutTranslation",
2044 "alignWithGroundRotation",
2045 "verticalOffset",
2046 "collisionFilterInfo",
2047 "forwardAlignFraction",
2048 "sidewaysAlignFraction",
2049 "sidewaysSampleWidth",
2050 "useTrackData",
2051 "lockFeetWhenPlanted",
2052 "useCharacterUpVector",
2053 "alignMode",
2054 "internalLegData",
2055 "prevIsFootIkEnabled",
2056 "isSetUp",
2057 "isGroundPositionValid",
2058 "timeStep",
2059 ];
2060 _serde::Deserializer::deserialize_struct(
2061 deserializer,
2062 "hkbFootIkModifier",
2063 FIELDS,
2064 __hkbFootIkModifierVisitor {
2065 marker: _serde::__private::PhantomData::<hkbFootIkModifier>,
2066 lifetime: _serde::__private::PhantomData,
2067 },
2068 )
2069 }
2070 }
2071};
2072#[allow(non_upper_case_globals, non_snake_case)]
2075#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
2076#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2077#[derive(
2078 Debug,
2079 Clone,
2080 Default,
2081 PartialEq,
2082 Eq,
2083 PartialOrd,
2084 Ord,
2085 num_derive::ToPrimitive,
2086 num_derive::FromPrimitive,
2087)]
2088pub enum AlignMode {
2089 #[default]
2090 ALIGN_MODE_FORWARD_RIGHT = 0isize,
2091 ALIGN_MODE_FORWARD = 1isize,
2092}
2093const _: () = {
2094 use havok_serde as __serde;
2095 impl __serde::Serialize for AlignMode {
2096 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
2097 where
2098 S: __serde::ser::Serializer,
2099 {
2100 let mut __serializer = __serializer.serialize_enum_flags()?;
2101 match self {
2102 Self::ALIGN_MODE_FORWARD_RIGHT => {
2103 __serializer.serialize_field("ALIGN_MODE_FORWARD_RIGHT", &0u64)
2104 }
2105 Self::ALIGN_MODE_FORWARD => {
2106 __serializer.serialize_field("ALIGN_MODE_FORWARD", &1u64)
2107 }
2108 }?;
2109 use num_traits::ToPrimitive as _;
2110 let num = self
2111 .to_i8()
2112 .ok_or(S::Error::custom("Failed enum AlignMode to_i8"))?;
2113 __serializer.serialize_bits(&num)?;
2114 __serializer.end()
2115 }
2116 }
2117};
2118#[doc(hidden)]
2119#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
2120const _: () = {
2121 #[allow(unused_extern_crates, clippy::useless_attribute)]
2122 extern crate havok_serde as _serde;
2123 #[automatically_derived]
2124 impl<'de> _serde::Deserialize<'de> for AlignMode {
2125 fn deserialize<__D>(
2126 __deserializer: __D,
2127 ) -> _serde::__private::Result<Self, __D::Error>
2128 where
2129 __D: _serde::Deserializer<'de>,
2130 {
2131 #[allow(non_camel_case_types)]
2132 #[doc(hidden)]
2133 enum __Field {
2134 __field0,
2135 __field1,
2136 }
2137 #[doc(hidden)]
2138 struct __FieldVisitor;
2139 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
2140 type Value = __Field;
2141 fn expecting(
2142 &self,
2143 __formatter: &mut _serde::__private::Formatter,
2144 ) -> _serde::__private::fmt::Result {
2145 _serde::__private::Formatter::write_str(
2146 __formatter,
2147 "variant identifier",
2148 )
2149 }
2150 fn visit_int8<__E>(
2151 self,
2152 __value: i8,
2153 ) -> _serde::__private::Result<Self::Value, __E>
2154 where
2155 __E: _serde::de::Error,
2156 {
2157 match __value {
2158 0i8 => _serde::__private::Ok(__Field::__field0),
2159 1i8 => _serde::__private::Ok(__Field::__field1),
2160 _ => {
2161 _serde::__private::Err(
2162 _serde::de::Error::invalid_value(
2163 _serde::de::Unexpected::Int8(__value),
2164 &"value(i8) of variant is one of 0, 1",
2165 ),
2166 )
2167 }
2168 }
2169 }
2170 fn visit_stringptr<__E>(
2171 self,
2172 __value: StringPtr<'de>,
2173 ) -> _serde::__private::Result<Self::Value, __E>
2174 where
2175 __E: _serde::de::Error,
2176 {
2177 if let Some(__value) = __value.into_inner() {
2178 match __value.as_ref() {
2179 v if v == "0"
2180 || v.eq_ignore_ascii_case("ALIGN_MODE_FORWARD_RIGHT") => {
2181 _serde::__private::Ok(__Field::__field0)
2182 }
2183 v if v == "1"
2184 || v.eq_ignore_ascii_case("ALIGN_MODE_FORWARD") => {
2185 _serde::__private::Ok(__Field::__field1)
2186 }
2187 _ => {
2188 _serde::__private::Err(
2189 _serde::de::Error::unknown_variant(&__value, VARIANTS),
2190 )
2191 }
2192 }
2193 } else {
2194 _serde::__private::Err(
2195 _serde::de::Error::unknown_variant("None", VARIANTS),
2196 )
2197 }
2198 }
2199 }
2200 impl<'de> _serde::Deserialize<'de> for __Field {
2201 #[inline]
2202 fn deserialize<__D>(
2203 __deserializer: __D,
2204 ) -> _serde::__private::Result<Self, __D::Error>
2205 where
2206 __D: _serde::Deserializer<'de>,
2207 {
2208 _serde::Deserializer::deserialize_identifier(
2209 __deserializer,
2210 _serde::de::ReadEnumSize::Int8,
2211 __FieldVisitor,
2212 )
2213 }
2214 }
2215 #[doc(hidden)]
2216 struct __Visitor<'de> {
2217 marker: _serde::__private::PhantomData<AlignMode>,
2218 lifetime: _serde::__private::PhantomData<&'de ()>,
2219 }
2220 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
2221 type Value = AlignMode;
2222 fn expecting(
2223 &self,
2224 __formatter: &mut _serde::__private::Formatter,
2225 ) -> _serde::__private::fmt::Result {
2226 _serde::__private::Formatter::write_str(
2227 __formatter,
2228 "enum AlignMode",
2229 )
2230 }
2231 fn visit_enum<__A>(
2232 self,
2233 __data: __A,
2234 ) -> _serde::__private::Result<Self::Value, __A::Error>
2235 where
2236 __A: _serde::de::EnumAccess<'de>,
2237 {
2238 match _serde::de::EnumAccess::variant(__data)? {
2239 (__Field::__field0, __variant) => {
2240 _serde::de::VariantAccess::unit_variant(__variant)?;
2241 _serde::__private::Ok(AlignMode::ALIGN_MODE_FORWARD_RIGHT)
2242 }
2243 (__Field::__field1, __variant) => {
2244 _serde::de::VariantAccess::unit_variant(__variant)?;
2245 _serde::__private::Ok(AlignMode::ALIGN_MODE_FORWARD)
2246 }
2247 }
2248 }
2249 }
2250 #[doc(hidden)]
2251 const VARIANTS: &'static [&'static str] = &[
2252 "ALIGN_MODE_FORWARD_RIGHT",
2253 "ALIGN_MODE_FORWARD",
2254 ];
2255 _serde::Deserializer::deserialize_enum(
2256 __deserializer,
2257 "AlignMode",
2258 VARIANTS,
2259 __Visitor {
2260 marker: _serde::__private::PhantomData::<AlignMode>,
2261 lifetime: _serde::__private::PhantomData,
2262 },
2263 )
2264 }
2265 }
2266};