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