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 hkbFootIkControlsModifier<'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 = "controlData"))]
36 #[cfg_attr(feature = "serde", serde(rename = "controlData"))]
37 pub m_controlData: hkbFootIkControlData,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "legs"))]
43 #[cfg_attr(feature = "serde", serde(rename = "legs"))]
44 pub m_legs: Vec<hkbFootIkControlsModifierLeg>,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "errorOutTranslation"))]
50 #[cfg_attr(feature = "serde", serde(rename = "errorOutTranslation"))]
51 pub m_errorOutTranslation: Vector4,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "alignWithGroundRotation"))]
57 #[cfg_attr(feature = "serde", serde(rename = "alignWithGroundRotation"))]
58 pub m_alignWithGroundRotation: Quaternion,
59}
60const _: () = {
61 use havok_serde as _serde;
62 impl<'a> _serde::HavokClass for hkbFootIkControlsModifier<'a> {
63 #[inline]
64 fn name(&self) -> &'static str {
65 "hkbFootIkControlsModifier"
66 }
67 #[inline]
68 fn signature(&self) -> _serde::__private::Signature {
69 _serde::__private::Signature::new(0xe5b6f544)
70 }
71 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
72 fn deps_indexes(&self) -> Vec<usize> {
73 let mut v = Vec::new();
74 v.push(self.parent.parent.parent.m_variableBindingSet.get());
75 v.extend(self.m_controlData.deps_indexes());
76 v.extend(
77 self
78 .m_legs
79 .iter()
80 .flat_map(|class| class.deps_indexes())
81 .collect::<Vec<usize>>(),
82 );
83 v
84 }
85 }
86 impl<'a> _serde::Serialize for hkbFootIkControlsModifier<'a> {
87 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
88 where
89 S: _serde::ser::Serializer,
90 {
91 let class_meta = self
92 .__ptr
93 .map(|name| (name, _serde::__private::Signature::new(0xe5b6f544)));
94 let mut serializer = __serializer
95 .serialize_struct(
96 "hkbFootIkControlsModifier",
97 class_meta,
98 (144u64, 176u64),
99 )?;
100 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
101 serializer
102 .skip_field(
103 "memSizeAndFlags",
104 &self.parent.parent.parent.parent.m_memSizeAndFlags,
105 )?;
106 serializer
107 .skip_field(
108 "referenceCount",
109 &self.parent.parent.parent.parent.m_referenceCount,
110 )?;
111 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
112 serializer
113 .serialize_field(
114 "variableBindingSet",
115 &self.parent.parent.parent.m_variableBindingSet,
116 )?;
117 serializer
118 .skip_array_field(
119 "cachedBindables",
120 &self.parent.parent.parent.m_cachedBindables,
121 TypeSize::NonPtr,
122 )?;
123 serializer
124 .skip_field(
125 "areBindablesCached",
126 &self.parent.parent.parent.m_areBindablesCached,
127 )?;
128 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
129 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
130 serializer.serialize_field("name", &self.parent.parent.m_name)?;
131 serializer.skip_field("id", &self.parent.parent.m_id)?;
132 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
133 serializer
134 .skip_fixed_array_field(
135 "padNode",
136 self.parent.parent.m_padNode.as_slice(),
137 TypeSize::NonPtr,
138 )?;
139 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
140 serializer.serialize_field("enable", &self.parent.m_enable)?;
141 serializer
142 .skip_fixed_array_field(
143 "padModifier",
144 self.parent.m_padModifier.as_slice(),
145 TypeSize::NonPtr,
146 )?;
147 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
148 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
149 serializer.serialize_field("controlData", &self.m_controlData)?;
150 serializer
151 .serialize_array_field(
152 "legs",
153 &self.m_legs,
154 TypeSize::Struct {
155 size_x86: 32u64,
156 size_x86_64: 48u64,
157 },
158 )?;
159 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
160 serializer
161 .serialize_field("errorOutTranslation", &self.m_errorOutTranslation)?;
162 serializer
163 .serialize_field(
164 "alignWithGroundRotation",
165 &self.m_alignWithGroundRotation,
166 )?;
167 serializer.end()
168 }
169 }
170};
171#[doc(hidden)]
172#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
173const _: () = {
174 use havok_serde as _serde;
175 #[automatically_derived]
176 impl<'de> _serde::Deserialize<'de> for hkbFootIkControlsModifier<'de> {
177 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
178 where
179 __D: _serde::Deserializer<'de>,
180 {
181 #[allow(non_camel_case_types)]
182 enum __Field {
183 m_variableBindingSet,
184 m_userData,
185 m_name,
186 m_enable,
187 m_controlData,
188 m_legs,
189 m_errorOutTranslation,
190 m_alignWithGroundRotation,
191 __ignore,
192 }
193 struct __FieldVisitor;
194 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
195 type Value = __Field;
196 fn expecting(
197 &self,
198 __formatter: &mut core::fmt::Formatter,
199 ) -> core::fmt::Result {
200 core::fmt::Formatter::write_str(__formatter, "field identifier")
201 }
202 #[allow(clippy::match_single_binding)]
204 #[allow(clippy::reversed_empty_ranges)]
205 #[allow(clippy::single_match)]
206 fn visit_key<__E>(
207 self,
208 __value: &str,
209 ) -> core::result::Result<Self::Value, __E>
210 where
211 __E: _serde::de::Error,
212 {
213 match __value {
214 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
215 "userData" => Ok(__Field::m_userData),
216 "name" => Ok(__Field::m_name),
217 "enable" => Ok(__Field::m_enable),
218 "controlData" => Ok(__Field::m_controlData),
219 "legs" => Ok(__Field::m_legs),
220 "errorOutTranslation" => Ok(__Field::m_errorOutTranslation),
221 "alignWithGroundRotation" => {
222 Ok(__Field::m_alignWithGroundRotation)
223 }
224 _ => Ok(__Field::__ignore),
225 }
226 }
227 }
228 impl<'de> _serde::Deserialize<'de> for __Field {
229 #[inline]
230 fn deserialize<__D>(
231 __deserializer: __D,
232 ) -> core::result::Result<Self, __D::Error>
233 where
234 __D: _serde::Deserializer<'de>,
235 {
236 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
237 }
238 }
239 struct __hkbFootIkControlsModifierVisitor<'de> {
240 marker: _serde::__private::PhantomData<hkbFootIkControlsModifier<'de>>,
241 lifetime: _serde::__private::PhantomData<&'de ()>,
242 }
243 #[allow(clippy::match_single_binding)]
244 #[allow(clippy::reversed_empty_ranges)]
245 #[allow(clippy::single_match)]
246 impl<'de> _serde::de::Visitor<'de>
247 for __hkbFootIkControlsModifierVisitor<'de> {
248 type Value = hkbFootIkControlsModifier<'de>;
249 fn expecting(
250 &self,
251 __formatter: &mut core::fmt::Formatter,
252 ) -> core::fmt::Result {
253 core::fmt::Formatter::write_str(
254 __formatter,
255 "struct hkbFootIkControlsModifier",
256 )
257 }
258 fn visit_struct_for_bytes<__A>(
259 self,
260 mut __map: __A,
261 ) -> _serde::__private::Result<Self::Value, __A::Error>
262 where
263 __A: _serde::de::MapAccess<'de>,
264 {
265 let __ptr = __A::class_ptr(&mut __map);
266 let parent = __A::parent_value(&mut __map)?;
267 let mut m_controlData: _serde::__private::Option<
268 hkbFootIkControlData,
269 > = _serde::__private::None;
270 let mut m_legs: _serde::__private::Option<
271 Vec<hkbFootIkControlsModifierLeg>,
272 > = _serde::__private::None;
273 let mut m_errorOutTranslation: _serde::__private::Option<Vector4> = _serde::__private::None;
274 let mut m_alignWithGroundRotation: _serde::__private::Option<
275 Quaternion,
276 > = _serde::__private::None;
277 for i in 0..4usize {
278 match i {
279 0usize => {
280 if _serde::__private::Option::is_some(&m_controlData) {
281 return _serde::__private::Err(
282 <__A::Error as _serde::de::Error>::duplicate_field(
283 "controlData",
284 ),
285 );
286 }
287 __A::pad(&mut __map, 4usize, 0usize)?;
288 m_controlData = _serde::__private::Some(
289 match __A::next_value::<hkbFootIkControlData>(&mut __map) {
290 _serde::__private::Ok(__val) => __val,
291 _serde::__private::Err(__err) => {
292 return _serde::__private::Err(__err);
293 }
294 },
295 );
296 }
297 1usize => {
298 if _serde::__private::Option::is_some(&m_legs) {
299 return _serde::__private::Err(
300 <__A::Error as _serde::de::Error>::duplicate_field("legs"),
301 );
302 }
303 m_legs = _serde::__private::Some(
304 match __A::next_value::<
305 Vec<hkbFootIkControlsModifierLeg>,
306 >(&mut __map) {
307 _serde::__private::Ok(__val) => __val,
308 _serde::__private::Err(__err) => {
309 return _serde::__private::Err(__err);
310 }
311 },
312 );
313 }
314 2usize => {
315 if _serde::__private::Option::is_some(
316 &m_errorOutTranslation,
317 ) {
318 return _serde::__private::Err(
319 <__A::Error as _serde::de::Error>::duplicate_field(
320 "errorOutTranslation",
321 ),
322 );
323 }
324 __A::pad(&mut __map, 4usize, 0usize)?;
325 m_errorOutTranslation = _serde::__private::Some(
326 match __A::next_value::<Vector4>(&mut __map) {
327 _serde::__private::Ok(__val) => __val,
328 _serde::__private::Err(__err) => {
329 return _serde::__private::Err(__err);
330 }
331 },
332 );
333 }
334 3usize => {
335 if _serde::__private::Option::is_some(
336 &m_alignWithGroundRotation,
337 ) {
338 return _serde::__private::Err(
339 <__A::Error as _serde::de::Error>::duplicate_field(
340 "alignWithGroundRotation",
341 ),
342 );
343 }
344 m_alignWithGroundRotation = _serde::__private::Some(
345 match __A::next_value::<Quaternion>(&mut __map) {
346 _serde::__private::Ok(__val) => __val,
347 _serde::__private::Err(__err) => {
348 return _serde::__private::Err(__err);
349 }
350 },
351 );
352 }
353 _ => {}
354 }
355 }
356 let m_controlData = match m_controlData {
357 _serde::__private::Some(__field) => __field,
358 _serde::__private::None => {
359 return _serde::__private::Err(
360 <__A::Error as _serde::de::Error>::missing_field(
361 "controlData",
362 ),
363 );
364 }
365 };
366 let m_legs = match m_legs {
367 _serde::__private::Some(__field) => __field,
368 _serde::__private::None => {
369 return _serde::__private::Err(
370 <__A::Error as _serde::de::Error>::missing_field("legs"),
371 );
372 }
373 };
374 let m_errorOutTranslation = match m_errorOutTranslation {
375 _serde::__private::Some(__field) => __field,
376 _serde::__private::None => {
377 return _serde::__private::Err(
378 <__A::Error as _serde::de::Error>::missing_field(
379 "errorOutTranslation",
380 ),
381 );
382 }
383 };
384 let m_alignWithGroundRotation = match m_alignWithGroundRotation {
385 _serde::__private::Some(__field) => __field,
386 _serde::__private::None => {
387 return _serde::__private::Err(
388 <__A::Error as _serde::de::Error>::missing_field(
389 "alignWithGroundRotation",
390 ),
391 );
392 }
393 };
394 _serde::__private::Ok(hkbFootIkControlsModifier {
395 __ptr,
396 parent,
397 m_controlData,
398 m_legs,
399 m_errorOutTranslation,
400 m_alignWithGroundRotation,
401 })
402 }
403 #[allow(clippy::manual_unwrap_or_default)]
404 fn visit_struct<__A>(
405 self,
406 mut __map: __A,
407 ) -> _serde::__private::Result<Self::Value, __A::Error>
408 where
409 __A: _serde::de::MapAccess<'de>,
410 {
411 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
412 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
413 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
414 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
415 let mut m_controlData: _serde::__private::Option<
416 hkbFootIkControlData,
417 > = _serde::__private::None;
418 let mut m_legs: _serde::__private::Option<
419 Vec<hkbFootIkControlsModifierLeg>,
420 > = _serde::__private::None;
421 let mut m_errorOutTranslation: _serde::__private::Option<Vector4> = _serde::__private::None;
422 let mut m_alignWithGroundRotation: _serde::__private::Option<
423 Quaternion,
424 > = _serde::__private::None;
425 while let _serde::__private::Some(__key) = {
426 __A::next_key::<__Field>(&mut __map)?
427 } {
428 match __key {
429 __Field::m_variableBindingSet => {
430 #[cfg(
431 any(feature = "strict", feature = "ignore_duplicates")
432 )]
433 if _serde::__private::Option::is_some(
434 &m_variableBindingSet,
435 ) {
436 #[cfg(feature = "ignore_duplicates")]
437 {
438 __A::skip_value(&mut __map)?;
439 continue;
440 }
441 #[cfg(feature = "strict")]
442 return _serde::__private::Err(
443 <__A::Error as _serde::de::Error>::duplicate_field(
444 "variableBindingSet",
445 ),
446 );
447 }
448 m_variableBindingSet = _serde::__private::Some(
449 match __A::next_value::<Pointer>(&mut __map) {
450 _serde::__private::Ok(__val) => __val,
451 _serde::__private::Err(__err) => {
452 return _serde::__private::Err(__err);
453 }
454 },
455 );
456 }
457 __Field::m_userData => {
458 #[cfg(
459 any(feature = "strict", feature = "ignore_duplicates")
460 )]
461 if _serde::__private::Option::is_some(&m_userData) {
462 #[cfg(feature = "ignore_duplicates")]
463 {
464 __A::skip_value(&mut __map)?;
465 continue;
466 }
467 #[cfg(feature = "strict")]
468 return _serde::__private::Err(
469 <__A::Error as _serde::de::Error>::duplicate_field(
470 "userData",
471 ),
472 );
473 }
474 m_userData = _serde::__private::Some(
475 match __A::next_value::<Ulong>(&mut __map) {
476 _serde::__private::Ok(__val) => __val,
477 _serde::__private::Err(__err) => {
478 return _serde::__private::Err(__err);
479 }
480 },
481 );
482 }
483 __Field::m_name => {
484 #[cfg(
485 any(feature = "strict", feature = "ignore_duplicates")
486 )]
487 if _serde::__private::Option::is_some(&m_name) {
488 #[cfg(feature = "ignore_duplicates")]
489 {
490 __A::skip_value(&mut __map)?;
491 continue;
492 }
493 #[cfg(feature = "strict")]
494 return _serde::__private::Err(
495 <__A::Error as _serde::de::Error>::duplicate_field("name"),
496 );
497 }
498 m_name = _serde::__private::Some(
499 match __A::next_value::<StringPtr<'de>>(&mut __map) {
500 _serde::__private::Ok(__val) => __val,
501 _serde::__private::Err(__err) => {
502 return _serde::__private::Err(__err);
503 }
504 },
505 );
506 }
507 __Field::m_enable => {
508 #[cfg(
509 any(feature = "strict", feature = "ignore_duplicates")
510 )]
511 if _serde::__private::Option::is_some(&m_enable) {
512 #[cfg(feature = "ignore_duplicates")]
513 {
514 __A::skip_value(&mut __map)?;
515 continue;
516 }
517 #[cfg(feature = "strict")]
518 return _serde::__private::Err(
519 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
520 );
521 }
522 m_enable = _serde::__private::Some(
523 match __A::next_value::<bool>(&mut __map) {
524 _serde::__private::Ok(__val) => __val,
525 _serde::__private::Err(__err) => {
526 return _serde::__private::Err(__err);
527 }
528 },
529 );
530 }
531 __Field::m_controlData => {
532 #[cfg(
533 any(feature = "strict", feature = "ignore_duplicates")
534 )]
535 if _serde::__private::Option::is_some(&m_controlData) {
536 #[cfg(feature = "ignore_duplicates")]
537 {
538 __A::skip_value(&mut __map)?;
539 continue;
540 }
541 #[cfg(feature = "strict")]
542 return _serde::__private::Err(
543 <__A::Error as _serde::de::Error>::duplicate_field(
544 "controlData",
545 ),
546 );
547 }
548 m_controlData = _serde::__private::Some(
549 match __A::next_value::<hkbFootIkControlData>(&mut __map) {
550 _serde::__private::Ok(__val) => __val,
551 _serde::__private::Err(__err) => {
552 return _serde::__private::Err(__err);
553 }
554 },
555 );
556 }
557 __Field::m_legs => {
558 #[cfg(
559 any(feature = "strict", feature = "ignore_duplicates")
560 )]
561 if _serde::__private::Option::is_some(&m_legs) {
562 #[cfg(feature = "ignore_duplicates")]
563 {
564 __A::skip_value(&mut __map)?;
565 continue;
566 }
567 #[cfg(feature = "strict")]
568 return _serde::__private::Err(
569 <__A::Error as _serde::de::Error>::duplicate_field("legs"),
570 );
571 }
572 m_legs = _serde::__private::Some(
573 match __A::next_value::<
574 Vec<hkbFootIkControlsModifierLeg>,
575 >(&mut __map) {
576 _serde::__private::Ok(__val) => __val,
577 _serde::__private::Err(__err) => {
578 return _serde::__private::Err(__err);
579 }
580 },
581 );
582 }
583 __Field::m_errorOutTranslation => {
584 #[cfg(
585 any(feature = "strict", feature = "ignore_duplicates")
586 )]
587 if _serde::__private::Option::is_some(
588 &m_errorOutTranslation,
589 ) {
590 #[cfg(feature = "ignore_duplicates")]
591 {
592 __A::skip_value(&mut __map)?;
593 continue;
594 }
595 #[cfg(feature = "strict")]
596 return _serde::__private::Err(
597 <__A::Error as _serde::de::Error>::duplicate_field(
598 "errorOutTranslation",
599 ),
600 );
601 }
602 m_errorOutTranslation = _serde::__private::Some(
603 match __A::next_value::<Vector4>(&mut __map) {
604 _serde::__private::Ok(__val) => __val,
605 _serde::__private::Err(__err) => {
606 return _serde::__private::Err(__err);
607 }
608 },
609 );
610 }
611 __Field::m_alignWithGroundRotation => {
612 #[cfg(
613 any(feature = "strict", feature = "ignore_duplicates")
614 )]
615 if _serde::__private::Option::is_some(
616 &m_alignWithGroundRotation,
617 ) {
618 #[cfg(feature = "ignore_duplicates")]
619 {
620 __A::skip_value(&mut __map)?;
621 continue;
622 }
623 #[cfg(feature = "strict")]
624 return _serde::__private::Err(
625 <__A::Error as _serde::de::Error>::duplicate_field(
626 "alignWithGroundRotation",
627 ),
628 );
629 }
630 m_alignWithGroundRotation = _serde::__private::Some(
631 match __A::next_value::<Quaternion>(&mut __map) {
632 _serde::__private::Ok(__val) => __val,
633 _serde::__private::Err(__err) => {
634 return _serde::__private::Err(__err);
635 }
636 },
637 );
638 }
639 _ => __A::skip_value(&mut __map)?,
640 }
641 }
642 let m_variableBindingSet = match m_variableBindingSet {
643 _serde::__private::Some(__field) => __field,
644 _serde::__private::None => {
645 #[cfg(feature = "strict")]
646 return _serde::__private::Err(
647 <__A::Error as _serde::de::Error>::missing_field(
648 "variableBindingSet",
649 ),
650 );
651 #[cfg(not(feature = "strict"))] Default::default()
652 }
653 };
654 let m_userData = match m_userData {
655 _serde::__private::Some(__field) => __field,
656 _serde::__private::None => {
657 #[cfg(feature = "strict")]
658 return _serde::__private::Err(
659 <__A::Error as _serde::de::Error>::missing_field("userData"),
660 );
661 #[cfg(not(feature = "strict"))] Default::default()
662 }
663 };
664 let m_name = match m_name {
665 _serde::__private::Some(__field) => __field,
666 _serde::__private::None => {
667 #[cfg(feature = "strict")]
668 return _serde::__private::Err(
669 <__A::Error as _serde::de::Error>::missing_field("name"),
670 );
671 #[cfg(not(feature = "strict"))] Default::default()
672 }
673 };
674 let m_enable = match m_enable {
675 _serde::__private::Some(__field) => __field,
676 _serde::__private::None => {
677 #[cfg(feature = "strict")]
678 return _serde::__private::Err(
679 <__A::Error as _serde::de::Error>::missing_field("enable"),
680 );
681 #[cfg(not(feature = "strict"))] Default::default()
682 }
683 };
684 let m_controlData = match m_controlData {
685 _serde::__private::Some(__field) => __field,
686 _serde::__private::None => {
687 #[cfg(feature = "strict")]
688 return _serde::__private::Err(
689 <__A::Error as _serde::de::Error>::missing_field(
690 "controlData",
691 ),
692 );
693 #[cfg(not(feature = "strict"))] Default::default()
694 }
695 };
696 let m_legs = match m_legs {
697 _serde::__private::Some(__field) => __field,
698 _serde::__private::None => {
699 #[cfg(feature = "strict")]
700 return _serde::__private::Err(
701 <__A::Error as _serde::de::Error>::missing_field("legs"),
702 );
703 #[cfg(not(feature = "strict"))] Default::default()
704 }
705 };
706 let m_errorOutTranslation = match m_errorOutTranslation {
707 _serde::__private::Some(__field) => __field,
708 _serde::__private::None => {
709 #[cfg(feature = "strict")]
710 return _serde::__private::Err(
711 <__A::Error as _serde::de::Error>::missing_field(
712 "errorOutTranslation",
713 ),
714 );
715 #[cfg(not(feature = "strict"))] Default::default()
716 }
717 };
718 let m_alignWithGroundRotation = match m_alignWithGroundRotation {
719 _serde::__private::Some(__field) => __field,
720 _serde::__private::None => {
721 #[cfg(feature = "strict")]
722 return _serde::__private::Err(
723 <__A::Error as _serde::de::Error>::missing_field(
724 "alignWithGroundRotation",
725 ),
726 );
727 #[cfg(not(feature = "strict"))] Default::default()
728 }
729 };
730 let __ptr = None;
731 let parent = hkBaseObject { __ptr };
732 let parent = hkReferencedObject {
733 __ptr,
734 parent,
735 ..Default::default()
736 };
737 let parent = hkbBindable {
738 __ptr,
739 parent,
740 m_variableBindingSet,
741 ..Default::default()
742 };
743 let parent = hkbNode {
744 __ptr,
745 parent,
746 m_userData,
747 m_name,
748 ..Default::default()
749 };
750 let parent = hkbModifier {
751 __ptr,
752 parent,
753 m_enable,
754 ..Default::default()
755 };
756 let __ptr = __A::class_ptr(&mut __map);
757 _serde::__private::Ok(hkbFootIkControlsModifier {
758 __ptr,
759 parent,
760 m_controlData,
761 m_legs,
762 m_errorOutTranslation,
763 m_alignWithGroundRotation,
764 })
765 }
766 }
767 const FIELDS: &[&str] = &[
768 "controlData",
769 "legs",
770 "errorOutTranslation",
771 "alignWithGroundRotation",
772 ];
773 _serde::Deserializer::deserialize_struct(
774 deserializer,
775 "hkbFootIkControlsModifier",
776 FIELDS,
777 __hkbFootIkControlsModifierVisitor {
778 marker: _serde::__private::PhantomData::<hkbFootIkControlsModifier>,
779 lifetime: _serde::__private::PhantomData,
780 },
781 )
782 }
783 }
784};