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