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 hkbGetUpModifier<'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 = "groundNormal"))]
36 #[cfg_attr(feature = "serde", serde(rename = "groundNormal"))]
37 pub m_groundNormal: Vector4,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "duration"))]
43 #[cfg_attr(feature = "serde", serde(rename = "duration"))]
44 pub m_duration: f32,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "alignWithGroundDuration"))]
50 #[cfg_attr(feature = "serde", serde(rename = "alignWithGroundDuration"))]
51 pub m_alignWithGroundDuration: f32,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "rootBoneIndex"))]
57 #[cfg_attr(feature = "serde", serde(rename = "rootBoneIndex"))]
58 pub m_rootBoneIndex: i16,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "otherBoneIndex"))]
64 #[cfg_attr(feature = "serde", serde(rename = "otherBoneIndex"))]
65 pub m_otherBoneIndex: i16,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "anotherBoneIndex"))]
71 #[cfg_attr(feature = "serde", serde(rename = "anotherBoneIndex"))]
72 pub m_anotherBoneIndex: i16,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "timeSinceBegin"))]
79 #[cfg_attr(feature = "serde", serde(rename = "timeSinceBegin"))]
80 pub m_timeSinceBegin: f32,
81 #[cfg_attr(feature = "json_schema", schemars(rename = "timeStep"))]
87 #[cfg_attr(feature = "serde", serde(rename = "timeStep"))]
88 pub m_timeStep: f32,
89 #[cfg_attr(feature = "json_schema", schemars(rename = "initNextModify"))]
95 #[cfg_attr(feature = "serde", serde(rename = "initNextModify"))]
96 pub m_initNextModify: bool,
97}
98const _: () = {
99 use havok_serde as _serde;
100 impl<'a> _serde::HavokClass for hkbGetUpModifier<'a> {
101 #[inline]
102 fn name(&self) -> &'static str {
103 "hkbGetUpModifier"
104 }
105 #[inline]
106 fn signature(&self) -> _serde::__private::Signature {
107 _serde::__private::Signature::new(0x61cb7ac0)
108 }
109 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
110 fn deps_indexes(&self) -> Vec<usize> {
111 let mut v = Vec::new();
112 v.push(self.parent.parent.parent.m_variableBindingSet.get());
113 v
114 }
115 }
116 impl<'a> _serde::Serialize for hkbGetUpModifier<'a> {
117 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
118 where
119 S: _serde::ser::Serializer,
120 {
121 let class_meta = self
122 .__ptr
123 .map(|name| (name, _serde::__private::Signature::new(0x61cb7ac0)));
124 let mut serializer = __serializer
125 .serialize_struct("hkbGetUpModifier", class_meta, (96u64, 128u64))?;
126 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
127 serializer
128 .skip_field(
129 "memSizeAndFlags",
130 &self.parent.parent.parent.parent.m_memSizeAndFlags,
131 )?;
132 serializer
133 .skip_field(
134 "referenceCount",
135 &self.parent.parent.parent.parent.m_referenceCount,
136 )?;
137 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
138 serializer
139 .serialize_field(
140 "variableBindingSet",
141 &self.parent.parent.parent.m_variableBindingSet,
142 )?;
143 serializer
144 .skip_array_field(
145 "cachedBindables",
146 &self.parent.parent.parent.m_cachedBindables,
147 TypeSize::NonPtr,
148 )?;
149 serializer
150 .skip_field(
151 "areBindablesCached",
152 &self.parent.parent.parent.m_areBindablesCached,
153 )?;
154 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
155 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
156 serializer.serialize_field("name", &self.parent.parent.m_name)?;
157 serializer.skip_field("id", &self.parent.parent.m_id)?;
158 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
159 serializer
160 .skip_fixed_array_field(
161 "padNode",
162 self.parent.parent.m_padNode.as_slice(),
163 TypeSize::NonPtr,
164 )?;
165 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
166 serializer.serialize_field("enable", &self.parent.m_enable)?;
167 serializer
168 .skip_fixed_array_field(
169 "padModifier",
170 self.parent.m_padModifier.as_slice(),
171 TypeSize::NonPtr,
172 )?;
173 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
174 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
175 serializer.serialize_field("groundNormal", &self.m_groundNormal)?;
176 serializer.serialize_field("duration", &self.m_duration)?;
177 serializer
178 .serialize_field(
179 "alignWithGroundDuration",
180 &self.m_alignWithGroundDuration,
181 )?;
182 serializer.serialize_field("rootBoneIndex", &self.m_rootBoneIndex)?;
183 serializer.serialize_field("otherBoneIndex", &self.m_otherBoneIndex)?;
184 serializer.serialize_field("anotherBoneIndex", &self.m_anotherBoneIndex)?;
185 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
186 serializer.skip_field("timeSinceBegin", &self.m_timeSinceBegin)?;
187 serializer.skip_field("timeStep", &self.m_timeStep)?;
188 serializer.skip_field("initNextModify", &self.m_initNextModify)?;
189 serializer.pad_field([0u8; 7usize].as_slice(), [0u8; 7usize].as_slice())?;
190 serializer.end()
191 }
192 }
193};
194#[doc(hidden)]
195#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
196const _: () = {
197 use havok_serde as _serde;
198 #[automatically_derived]
199 impl<'de> _serde::Deserialize<'de> for hkbGetUpModifier<'de> {
200 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
201 where
202 __D: _serde::Deserializer<'de>,
203 {
204 #[allow(non_camel_case_types)]
205 enum __Field {
206 m_variableBindingSet,
207 m_userData,
208 m_name,
209 m_enable,
210 m_groundNormal,
211 m_duration,
212 m_alignWithGroundDuration,
213 m_rootBoneIndex,
214 m_otherBoneIndex,
215 m_anotherBoneIndex,
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 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
240 "userData" => Ok(__Field::m_userData),
241 "name" => Ok(__Field::m_name),
242 "enable" => Ok(__Field::m_enable),
243 "groundNormal" => Ok(__Field::m_groundNormal),
244 "duration" => Ok(__Field::m_duration),
245 "alignWithGroundDuration" => {
246 Ok(__Field::m_alignWithGroundDuration)
247 }
248 "rootBoneIndex" => Ok(__Field::m_rootBoneIndex),
249 "otherBoneIndex" => Ok(__Field::m_otherBoneIndex),
250 "anotherBoneIndex" => Ok(__Field::m_anotherBoneIndex),
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 __hkbGetUpModifierVisitor<'de> {
267 marker: _serde::__private::PhantomData<hkbGetUpModifier<'de>>,
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 __hkbGetUpModifierVisitor<'de> {
274 type Value = hkbGetUpModifier<'de>;
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 hkbGetUpModifier",
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_groundNormal: _serde::__private::Option<Vector4> = _serde::__private::None;
294 let mut m_duration: _serde::__private::Option<f32> = _serde::__private::None;
295 let mut m_alignWithGroundDuration: _serde::__private::Option<f32> = _serde::__private::None;
296 let mut m_rootBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
297 let mut m_otherBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
298 let mut m_anotherBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
299 let mut m_timeSinceBegin: _serde::__private::Option<f32> = _serde::__private::None;
300 let mut m_timeStep: _serde::__private::Option<f32> = _serde::__private::None;
301 let mut m_initNextModify: _serde::__private::Option<bool> = _serde::__private::None;
302 for i in 0..9usize {
303 match i {
304 0usize => {
305 if _serde::__private::Option::is_some(&m_groundNormal) {
306 return _serde::__private::Err(
307 <__A::Error as _serde::de::Error>::duplicate_field(
308 "groundNormal",
309 ),
310 );
311 }
312 __A::pad(&mut __map, 4usize, 0usize)?;
313 m_groundNormal = _serde::__private::Some(
314 match __A::next_value::<Vector4>(&mut __map) {
315 _serde::__private::Ok(__val) => __val,
316 _serde::__private::Err(__err) => {
317 return _serde::__private::Err(__err);
318 }
319 },
320 );
321 }
322 1usize => {
323 if _serde::__private::Option::is_some(&m_duration) {
324 return _serde::__private::Err(
325 <__A::Error as _serde::de::Error>::duplicate_field(
326 "duration",
327 ),
328 );
329 }
330 m_duration = _serde::__private::Some(
331 match __A::next_value::<f32>(&mut __map) {
332 _serde::__private::Ok(__val) => __val,
333 _serde::__private::Err(__err) => {
334 return _serde::__private::Err(__err);
335 }
336 },
337 );
338 }
339 2usize => {
340 if _serde::__private::Option::is_some(
341 &m_alignWithGroundDuration,
342 ) {
343 return _serde::__private::Err(
344 <__A::Error as _serde::de::Error>::duplicate_field(
345 "alignWithGroundDuration",
346 ),
347 );
348 }
349 m_alignWithGroundDuration = _serde::__private::Some(
350 match __A::next_value::<f32>(&mut __map) {
351 _serde::__private::Ok(__val) => __val,
352 _serde::__private::Err(__err) => {
353 return _serde::__private::Err(__err);
354 }
355 },
356 );
357 }
358 3usize => {
359 if _serde::__private::Option::is_some(&m_rootBoneIndex) {
360 return _serde::__private::Err(
361 <__A::Error as _serde::de::Error>::duplicate_field(
362 "rootBoneIndex",
363 ),
364 );
365 }
366 m_rootBoneIndex = _serde::__private::Some(
367 match __A::next_value::<i16>(&mut __map) {
368 _serde::__private::Ok(__val) => __val,
369 _serde::__private::Err(__err) => {
370 return _serde::__private::Err(__err);
371 }
372 },
373 );
374 }
375 4usize => {
376 if _serde::__private::Option::is_some(&m_otherBoneIndex) {
377 return _serde::__private::Err(
378 <__A::Error as _serde::de::Error>::duplicate_field(
379 "otherBoneIndex",
380 ),
381 );
382 }
383 m_otherBoneIndex = _serde::__private::Some(
384 match __A::next_value::<i16>(&mut __map) {
385 _serde::__private::Ok(__val) => __val,
386 _serde::__private::Err(__err) => {
387 return _serde::__private::Err(__err);
388 }
389 },
390 );
391 }
392 5usize => {
393 if _serde::__private::Option::is_some(&m_anotherBoneIndex) {
394 return _serde::__private::Err(
395 <__A::Error as _serde::de::Error>::duplicate_field(
396 "anotherBoneIndex",
397 ),
398 );
399 }
400 m_anotherBoneIndex = _serde::__private::Some(
401 match __A::next_value::<i16>(&mut __map) {
402 _serde::__private::Ok(__val) => __val,
403 _serde::__private::Err(__err) => {
404 return _serde::__private::Err(__err);
405 }
406 },
407 );
408 }
409 6usize => {
410 if _serde::__private::Option::is_some(&m_timeSinceBegin) {
411 return _serde::__private::Err(
412 <__A::Error as _serde::de::Error>::duplicate_field(
413 "timeSinceBegin",
414 ),
415 );
416 }
417 __A::pad(&mut __map, 2usize, 2usize)?;
418 m_timeSinceBegin = _serde::__private::Some(
419 match __A::next_value::<f32>(&mut __map) {
420 _serde::__private::Ok(__val) => __val,
421 _serde::__private::Err(__err) => {
422 return _serde::__private::Err(__err);
423 }
424 },
425 );
426 }
427 7usize => {
428 if _serde::__private::Option::is_some(&m_timeStep) {
429 return _serde::__private::Err(
430 <__A::Error as _serde::de::Error>::duplicate_field(
431 "timeStep",
432 ),
433 );
434 }
435 m_timeStep = _serde::__private::Some(
436 match __A::next_value::<f32>(&mut __map) {
437 _serde::__private::Ok(__val) => __val,
438 _serde::__private::Err(__err) => {
439 return _serde::__private::Err(__err);
440 }
441 },
442 );
443 }
444 8usize => {
445 if _serde::__private::Option::is_some(&m_initNextModify) {
446 return _serde::__private::Err(
447 <__A::Error as _serde::de::Error>::duplicate_field(
448 "initNextModify",
449 ),
450 );
451 }
452 m_initNextModify = _serde::__private::Some(
453 match __A::next_value::<bool>(&mut __map) {
454 _serde::__private::Ok(__val) => __val,
455 _serde::__private::Err(__err) => {
456 return _serde::__private::Err(__err);
457 }
458 },
459 );
460 }
461 _ => {}
462 }
463 }
464 __A::pad(&mut __map, 7usize, 7usize)?;
465 let m_groundNormal = match m_groundNormal {
466 _serde::__private::Some(__field) => __field,
467 _serde::__private::None => {
468 return _serde::__private::Err(
469 <__A::Error as _serde::de::Error>::missing_field(
470 "groundNormal",
471 ),
472 );
473 }
474 };
475 let m_duration = match m_duration {
476 _serde::__private::Some(__field) => __field,
477 _serde::__private::None => {
478 return _serde::__private::Err(
479 <__A::Error as _serde::de::Error>::missing_field("duration"),
480 );
481 }
482 };
483 let m_alignWithGroundDuration = match m_alignWithGroundDuration {
484 _serde::__private::Some(__field) => __field,
485 _serde::__private::None => {
486 return _serde::__private::Err(
487 <__A::Error as _serde::de::Error>::missing_field(
488 "alignWithGroundDuration",
489 ),
490 );
491 }
492 };
493 let m_rootBoneIndex = match m_rootBoneIndex {
494 _serde::__private::Some(__field) => __field,
495 _serde::__private::None => {
496 return _serde::__private::Err(
497 <__A::Error as _serde::de::Error>::missing_field(
498 "rootBoneIndex",
499 ),
500 );
501 }
502 };
503 let m_otherBoneIndex = match m_otherBoneIndex {
504 _serde::__private::Some(__field) => __field,
505 _serde::__private::None => {
506 return _serde::__private::Err(
507 <__A::Error as _serde::de::Error>::missing_field(
508 "otherBoneIndex",
509 ),
510 );
511 }
512 };
513 let m_anotherBoneIndex = match m_anotherBoneIndex {
514 _serde::__private::Some(__field) => __field,
515 _serde::__private::None => {
516 return _serde::__private::Err(
517 <__A::Error as _serde::de::Error>::missing_field(
518 "anotherBoneIndex",
519 ),
520 );
521 }
522 };
523 let m_timeSinceBegin = match m_timeSinceBegin {
524 _serde::__private::Some(__field) => __field,
525 _serde::__private::None => {
526 return _serde::__private::Err(
527 <__A::Error as _serde::de::Error>::missing_field(
528 "timeSinceBegin",
529 ),
530 );
531 }
532 };
533 let m_timeStep = match m_timeStep {
534 _serde::__private::Some(__field) => __field,
535 _serde::__private::None => {
536 return _serde::__private::Err(
537 <__A::Error as _serde::de::Error>::missing_field("timeStep"),
538 );
539 }
540 };
541 let m_initNextModify = match m_initNextModify {
542 _serde::__private::Some(__field) => __field,
543 _serde::__private::None => {
544 return _serde::__private::Err(
545 <__A::Error as _serde::de::Error>::missing_field(
546 "initNextModify",
547 ),
548 );
549 }
550 };
551 _serde::__private::Ok(hkbGetUpModifier {
552 __ptr,
553 parent,
554 m_groundNormal,
555 m_duration,
556 m_alignWithGroundDuration,
557 m_rootBoneIndex,
558 m_otherBoneIndex,
559 m_anotherBoneIndex,
560 m_timeSinceBegin,
561 m_timeStep,
562 m_initNextModify,
563 })
564 }
565 #[allow(clippy::manual_unwrap_or_default)]
566 fn visit_struct<__A>(
567 self,
568 mut __map: __A,
569 ) -> _serde::__private::Result<Self::Value, __A::Error>
570 where
571 __A: _serde::de::MapAccess<'de>,
572 {
573 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
574 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
575 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
576 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
577 let mut m_groundNormal: _serde::__private::Option<Vector4> = _serde::__private::None;
578 let mut m_duration: _serde::__private::Option<f32> = _serde::__private::None;
579 let mut m_alignWithGroundDuration: _serde::__private::Option<f32> = _serde::__private::None;
580 let mut m_rootBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
581 let mut m_otherBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
582 let mut m_anotherBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
583 while let _serde::__private::Some(__key) = {
584 __A::next_key::<__Field>(&mut __map)?
585 } {
586 match __key {
587 __Field::m_variableBindingSet => {
588 #[cfg(
589 any(feature = "strict", feature = "ignore_duplicates")
590 )]
591 if _serde::__private::Option::is_some(
592 &m_variableBindingSet,
593 ) {
594 #[cfg(feature = "ignore_duplicates")]
595 {
596 __A::skip_value(&mut __map)?;
597 continue;
598 }
599 #[cfg(feature = "strict")]
600 return _serde::__private::Err(
601 <__A::Error as _serde::de::Error>::duplicate_field(
602 "variableBindingSet",
603 ),
604 );
605 }
606 m_variableBindingSet = _serde::__private::Some(
607 match __A::next_value::<Pointer>(&mut __map) {
608 _serde::__private::Ok(__val) => __val,
609 _serde::__private::Err(__err) => {
610 return _serde::__private::Err(__err);
611 }
612 },
613 );
614 }
615 __Field::m_userData => {
616 #[cfg(
617 any(feature = "strict", feature = "ignore_duplicates")
618 )]
619 if _serde::__private::Option::is_some(&m_userData) {
620 #[cfg(feature = "ignore_duplicates")]
621 {
622 __A::skip_value(&mut __map)?;
623 continue;
624 }
625 #[cfg(feature = "strict")]
626 return _serde::__private::Err(
627 <__A::Error as _serde::de::Error>::duplicate_field(
628 "userData",
629 ),
630 );
631 }
632 m_userData = _serde::__private::Some(
633 match __A::next_value::<Ulong>(&mut __map) {
634 _serde::__private::Ok(__val) => __val,
635 _serde::__private::Err(__err) => {
636 return _serde::__private::Err(__err);
637 }
638 },
639 );
640 }
641 __Field::m_name => {
642 #[cfg(
643 any(feature = "strict", feature = "ignore_duplicates")
644 )]
645 if _serde::__private::Option::is_some(&m_name) {
646 #[cfg(feature = "ignore_duplicates")]
647 {
648 __A::skip_value(&mut __map)?;
649 continue;
650 }
651 #[cfg(feature = "strict")]
652 return _serde::__private::Err(
653 <__A::Error as _serde::de::Error>::duplicate_field("name"),
654 );
655 }
656 m_name = _serde::__private::Some(
657 match __A::next_value::<StringPtr<'de>>(&mut __map) {
658 _serde::__private::Ok(__val) => __val,
659 _serde::__private::Err(__err) => {
660 return _serde::__private::Err(__err);
661 }
662 },
663 );
664 }
665 __Field::m_enable => {
666 #[cfg(
667 any(feature = "strict", feature = "ignore_duplicates")
668 )]
669 if _serde::__private::Option::is_some(&m_enable) {
670 #[cfg(feature = "ignore_duplicates")]
671 {
672 __A::skip_value(&mut __map)?;
673 continue;
674 }
675 #[cfg(feature = "strict")]
676 return _serde::__private::Err(
677 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
678 );
679 }
680 m_enable = _serde::__private::Some(
681 match __A::next_value::<bool>(&mut __map) {
682 _serde::__private::Ok(__val) => __val,
683 _serde::__private::Err(__err) => {
684 return _serde::__private::Err(__err);
685 }
686 },
687 );
688 }
689 __Field::m_groundNormal => {
690 #[cfg(
691 any(feature = "strict", feature = "ignore_duplicates")
692 )]
693 if _serde::__private::Option::is_some(&m_groundNormal) {
694 #[cfg(feature = "ignore_duplicates")]
695 {
696 __A::skip_value(&mut __map)?;
697 continue;
698 }
699 #[cfg(feature = "strict")]
700 return _serde::__private::Err(
701 <__A::Error as _serde::de::Error>::duplicate_field(
702 "groundNormal",
703 ),
704 );
705 }
706 m_groundNormal = _serde::__private::Some(
707 match __A::next_value::<Vector4>(&mut __map) {
708 _serde::__private::Ok(__val) => __val,
709 _serde::__private::Err(__err) => {
710 return _serde::__private::Err(__err);
711 }
712 },
713 );
714 }
715 __Field::m_duration => {
716 #[cfg(
717 any(feature = "strict", feature = "ignore_duplicates")
718 )]
719 if _serde::__private::Option::is_some(&m_duration) {
720 #[cfg(feature = "ignore_duplicates")]
721 {
722 __A::skip_value(&mut __map)?;
723 continue;
724 }
725 #[cfg(feature = "strict")]
726 return _serde::__private::Err(
727 <__A::Error as _serde::de::Error>::duplicate_field(
728 "duration",
729 ),
730 );
731 }
732 m_duration = _serde::__private::Some(
733 match __A::next_value::<f32>(&mut __map) {
734 _serde::__private::Ok(__val) => __val,
735 _serde::__private::Err(__err) => {
736 return _serde::__private::Err(__err);
737 }
738 },
739 );
740 }
741 __Field::m_alignWithGroundDuration => {
742 #[cfg(
743 any(feature = "strict", feature = "ignore_duplicates")
744 )]
745 if _serde::__private::Option::is_some(
746 &m_alignWithGroundDuration,
747 ) {
748 #[cfg(feature = "ignore_duplicates")]
749 {
750 __A::skip_value(&mut __map)?;
751 continue;
752 }
753 #[cfg(feature = "strict")]
754 return _serde::__private::Err(
755 <__A::Error as _serde::de::Error>::duplicate_field(
756 "alignWithGroundDuration",
757 ),
758 );
759 }
760 m_alignWithGroundDuration = _serde::__private::Some(
761 match __A::next_value::<f32>(&mut __map) {
762 _serde::__private::Ok(__val) => __val,
763 _serde::__private::Err(__err) => {
764 return _serde::__private::Err(__err);
765 }
766 },
767 );
768 }
769 __Field::m_rootBoneIndex => {
770 #[cfg(
771 any(feature = "strict", feature = "ignore_duplicates")
772 )]
773 if _serde::__private::Option::is_some(&m_rootBoneIndex) {
774 #[cfg(feature = "ignore_duplicates")]
775 {
776 __A::skip_value(&mut __map)?;
777 continue;
778 }
779 #[cfg(feature = "strict")]
780 return _serde::__private::Err(
781 <__A::Error as _serde::de::Error>::duplicate_field(
782 "rootBoneIndex",
783 ),
784 );
785 }
786 m_rootBoneIndex = _serde::__private::Some(
787 match __A::next_value::<i16>(&mut __map) {
788 _serde::__private::Ok(__val) => __val,
789 _serde::__private::Err(__err) => {
790 return _serde::__private::Err(__err);
791 }
792 },
793 );
794 }
795 __Field::m_otherBoneIndex => {
796 #[cfg(
797 any(feature = "strict", feature = "ignore_duplicates")
798 )]
799 if _serde::__private::Option::is_some(&m_otherBoneIndex) {
800 #[cfg(feature = "ignore_duplicates")]
801 {
802 __A::skip_value(&mut __map)?;
803 continue;
804 }
805 #[cfg(feature = "strict")]
806 return _serde::__private::Err(
807 <__A::Error as _serde::de::Error>::duplicate_field(
808 "otherBoneIndex",
809 ),
810 );
811 }
812 m_otherBoneIndex = _serde::__private::Some(
813 match __A::next_value::<i16>(&mut __map) {
814 _serde::__private::Ok(__val) => __val,
815 _serde::__private::Err(__err) => {
816 return _serde::__private::Err(__err);
817 }
818 },
819 );
820 }
821 __Field::m_anotherBoneIndex => {
822 #[cfg(
823 any(feature = "strict", feature = "ignore_duplicates")
824 )]
825 if _serde::__private::Option::is_some(&m_anotherBoneIndex) {
826 #[cfg(feature = "ignore_duplicates")]
827 {
828 __A::skip_value(&mut __map)?;
829 continue;
830 }
831 #[cfg(feature = "strict")]
832 return _serde::__private::Err(
833 <__A::Error as _serde::de::Error>::duplicate_field(
834 "anotherBoneIndex",
835 ),
836 );
837 }
838 m_anotherBoneIndex = _serde::__private::Some(
839 match __A::next_value::<i16>(&mut __map) {
840 _serde::__private::Ok(__val) => __val,
841 _serde::__private::Err(__err) => {
842 return _serde::__private::Err(__err);
843 }
844 },
845 );
846 }
847 _ => __A::skip_value(&mut __map)?,
848 }
849 }
850 let m_variableBindingSet = match m_variableBindingSet {
851 _serde::__private::Some(__field) => __field,
852 _serde::__private::None => {
853 #[cfg(feature = "strict")]
854 return _serde::__private::Err(
855 <__A::Error as _serde::de::Error>::missing_field(
856 "variableBindingSet",
857 ),
858 );
859 #[cfg(not(feature = "strict"))] Default::default()
860 }
861 };
862 let m_userData = match m_userData {
863 _serde::__private::Some(__field) => __field,
864 _serde::__private::None => {
865 #[cfg(feature = "strict")]
866 return _serde::__private::Err(
867 <__A::Error as _serde::de::Error>::missing_field("userData"),
868 );
869 #[cfg(not(feature = "strict"))] Default::default()
870 }
871 };
872 let m_name = match m_name {
873 _serde::__private::Some(__field) => __field,
874 _serde::__private::None => {
875 #[cfg(feature = "strict")]
876 return _serde::__private::Err(
877 <__A::Error as _serde::de::Error>::missing_field("name"),
878 );
879 #[cfg(not(feature = "strict"))] Default::default()
880 }
881 };
882 let m_enable = match m_enable {
883 _serde::__private::Some(__field) => __field,
884 _serde::__private::None => {
885 #[cfg(feature = "strict")]
886 return _serde::__private::Err(
887 <__A::Error as _serde::de::Error>::missing_field("enable"),
888 );
889 #[cfg(not(feature = "strict"))] Default::default()
890 }
891 };
892 let m_groundNormal = match m_groundNormal {
893 _serde::__private::Some(__field) => __field,
894 _serde::__private::None => {
895 #[cfg(feature = "strict")]
896 return _serde::__private::Err(
897 <__A::Error as _serde::de::Error>::missing_field(
898 "groundNormal",
899 ),
900 );
901 #[cfg(not(feature = "strict"))] Default::default()
902 }
903 };
904 let m_duration = match m_duration {
905 _serde::__private::Some(__field) => __field,
906 _serde::__private::None => {
907 #[cfg(feature = "strict")]
908 return _serde::__private::Err(
909 <__A::Error as _serde::de::Error>::missing_field("duration"),
910 );
911 #[cfg(not(feature = "strict"))] Default::default()
912 }
913 };
914 let m_alignWithGroundDuration = match m_alignWithGroundDuration {
915 _serde::__private::Some(__field) => __field,
916 _serde::__private::None => {
917 #[cfg(feature = "strict")]
918 return _serde::__private::Err(
919 <__A::Error as _serde::de::Error>::missing_field(
920 "alignWithGroundDuration",
921 ),
922 );
923 #[cfg(not(feature = "strict"))] Default::default()
924 }
925 };
926 let m_rootBoneIndex = match m_rootBoneIndex {
927 _serde::__private::Some(__field) => __field,
928 _serde::__private::None => {
929 #[cfg(feature = "strict")]
930 return _serde::__private::Err(
931 <__A::Error as _serde::de::Error>::missing_field(
932 "rootBoneIndex",
933 ),
934 );
935 #[cfg(not(feature = "strict"))] Default::default()
936 }
937 };
938 let m_otherBoneIndex = match m_otherBoneIndex {
939 _serde::__private::Some(__field) => __field,
940 _serde::__private::None => {
941 #[cfg(feature = "strict")]
942 return _serde::__private::Err(
943 <__A::Error as _serde::de::Error>::missing_field(
944 "otherBoneIndex",
945 ),
946 );
947 #[cfg(not(feature = "strict"))] Default::default()
948 }
949 };
950 let m_anotherBoneIndex = match m_anotherBoneIndex {
951 _serde::__private::Some(__field) => __field,
952 _serde::__private::None => {
953 #[cfg(feature = "strict")]
954 return _serde::__private::Err(
955 <__A::Error as _serde::de::Error>::missing_field(
956 "anotherBoneIndex",
957 ),
958 );
959 #[cfg(not(feature = "strict"))] Default::default()
960 }
961 };
962 let __ptr = None;
963 let parent = hkBaseObject { __ptr };
964 let parent = hkReferencedObject {
965 __ptr,
966 parent,
967 ..Default::default()
968 };
969 let parent = hkbBindable {
970 __ptr,
971 parent,
972 m_variableBindingSet,
973 ..Default::default()
974 };
975 let parent = hkbNode {
976 __ptr,
977 parent,
978 m_userData,
979 m_name,
980 ..Default::default()
981 };
982 let parent = hkbModifier {
983 __ptr,
984 parent,
985 m_enable,
986 ..Default::default()
987 };
988 let __ptr = __A::class_ptr(&mut __map);
989 _serde::__private::Ok(hkbGetUpModifier {
990 __ptr,
991 parent,
992 m_groundNormal,
993 m_duration,
994 m_alignWithGroundDuration,
995 m_rootBoneIndex,
996 m_otherBoneIndex,
997 m_anotherBoneIndex,
998 ..Default::default()
999 })
1000 }
1001 }
1002 const FIELDS: &[&str] = &[
1003 "groundNormal",
1004 "duration",
1005 "alignWithGroundDuration",
1006 "rootBoneIndex",
1007 "otherBoneIndex",
1008 "anotherBoneIndex",
1009 "timeSinceBegin",
1010 "timeStep",
1011 "initNextModify",
1012 ];
1013 _serde::Deserializer::deserialize_struct(
1014 deserializer,
1015 "hkbGetUpModifier",
1016 FIELDS,
1017 __hkbGetUpModifierVisitor {
1018 marker: _serde::__private::PhantomData::<hkbGetUpModifier>,
1019 lifetime: _serde::__private::PhantomData,
1020 },
1021 )
1022 }
1023 }
1024};