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