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 hkbClientCharacterState<'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 = "json_schema", schemars(rename = "deformableSkinIds"))]
35 #[cfg_attr(feature = "serde", serde(rename = "deformableSkinIds"))]
36 pub m_deformableSkinIds: Vec<u64>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "rigidSkinIds"))]
42 #[cfg_attr(feature = "serde", serde(rename = "rigidSkinIds"))]
43 pub m_rigidSkinIds: Vec<u64>,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "externalEventIds"))]
49 #[cfg_attr(feature = "serde", serde(rename = "externalEventIds"))]
50 pub m_externalEventIds: Vec<i16>,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "auxiliaryInfo"))]
56 #[cfg_attr(feature = "serde", serde(rename = "auxiliaryInfo"))]
57 pub m_auxiliaryInfo: Vec<Pointer>,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "activeEventIds"))]
63 #[cfg_attr(feature = "serde", serde(rename = "activeEventIds"))]
64 pub m_activeEventIds: Vec<i16>,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "activeVariableIds"))]
70 #[cfg_attr(feature = "serde", serde(rename = "activeVariableIds"))]
71 pub m_activeVariableIds: Vec<i16>,
72 #[cfg_attr(feature = "json_schema", schemars(rename = "characterId"))]
77 #[cfg_attr(feature = "serde", serde(rename = "characterId"))]
78 pub m_characterId: u64,
79 #[cfg_attr(feature = "serde", serde(borrow))]
84 #[cfg_attr(feature = "json_schema", schemars(rename = "instanceName"))]
85 #[cfg_attr(feature = "serde", serde(rename = "instanceName"))]
86 pub m_instanceName: StringPtr<'a>,
87 #[cfg_attr(feature = "serde", serde(borrow))]
92 #[cfg_attr(feature = "json_schema", schemars(rename = "templateName"))]
93 #[cfg_attr(feature = "serde", serde(rename = "templateName"))]
94 pub m_templateName: StringPtr<'a>,
95 #[cfg_attr(feature = "serde", serde(borrow))]
100 #[cfg_attr(feature = "json_schema", schemars(rename = "fullPathToProject"))]
101 #[cfg_attr(feature = "serde", serde(rename = "fullPathToProject"))]
102 pub m_fullPathToProject: StringPtr<'a>,
103 #[cfg_attr(feature = "json_schema", schemars(rename = "behaviorData"))]
108 #[cfg_attr(feature = "serde", serde(rename = "behaviorData"))]
109 pub m_behaviorData: Pointer,
110 #[cfg_attr(feature = "json_schema", schemars(rename = "behaviorInternalState"))]
115 #[cfg_attr(feature = "serde", serde(rename = "behaviorInternalState"))]
116 pub m_behaviorInternalState: Pointer,
117 #[cfg_attr(feature = "json_schema", schemars(rename = "nodeIdToInternalStateMap"))]
123 #[cfg_attr(feature = "serde", serde(rename = "nodeIdToInternalStateMap"))]
124 pub m_nodeIdToInternalStateMap: Pointer,
125 #[cfg_attr(feature = "json_schema", schemars(rename = "visible"))]
130 #[cfg_attr(feature = "serde", serde(rename = "visible"))]
131 pub m_visible: bool,
132 #[cfg_attr(feature = "json_schema", schemars(rename = "elapsedSimulationTime"))]
137 #[cfg_attr(feature = "serde", serde(rename = "elapsedSimulationTime"))]
138 pub m_elapsedSimulationTime: f32,
139 #[cfg_attr(feature = "json_schema", schemars(rename = "skeleton"))]
144 #[cfg_attr(feature = "serde", serde(rename = "skeleton"))]
145 pub m_skeleton: Pointer,
146 #[cfg_attr(feature = "json_schema", schemars(rename = "worldFromModel"))]
151 #[cfg_attr(feature = "serde", serde(rename = "worldFromModel"))]
152 pub m_worldFromModel: QsTransform,
153 #[cfg_attr(feature = "json_schema", schemars(rename = "poseModelSpace"))]
158 #[cfg_attr(feature = "serde", serde(rename = "poseModelSpace"))]
159 pub m_poseModelSpace: Vec<QsTransform>,
160 #[cfg_attr(feature = "json_schema", schemars(rename = "rigidAttachmentTransforms"))]
165 #[cfg_attr(feature = "serde", serde(rename = "rigidAttachmentTransforms"))]
166 pub m_rigidAttachmentTransforms: Vec<QsTransform>,
167}
168const _: () = {
169 use havok_serde as _serde;
170 impl<'a> _serde::HavokClass for hkbClientCharacterState<'a> {
171 #[inline]
172 fn name(&self) -> &'static str {
173 "hkbClientCharacterState"
174 }
175 #[inline]
176 fn signature(&self) -> _serde::__private::Signature {
177 _serde::__private::Signature::new(0xa2624c97)
178 }
179 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
180 fn deps_indexes(&self) -> Vec<usize> {
181 let mut v = Vec::new();
182 v.extend(self.m_auxiliaryInfo.iter().map(|ptr| ptr.get()));
183 v.push(self.m_behaviorData.get());
184 v.push(self.m_behaviorInternalState.get());
185 v.push(self.m_nodeIdToInternalStateMap.get());
186 v.push(self.m_skeleton.get());
187 v
188 }
189 }
190 impl<'a> _serde::Serialize for hkbClientCharacterState<'a> {
191 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
192 where
193 S: _serde::ser::Serializer,
194 {
195 let class_meta = self
196 .__ptr
197 .map(|name| (name, _serde::__private::Signature::new(0xa2624c97)));
198 let mut serializer = __serializer
199 .serialize_struct(
200 "hkbClientCharacterState",
201 class_meta,
202 (208u64, 272u64),
203 )?;
204 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
205 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
206 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
207 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
208 serializer
209 .serialize_array_field(
210 "deformableSkinIds",
211 &self.m_deformableSkinIds,
212 TypeSize::NonPtr,
213 )?;
214 serializer
215 .serialize_array_field(
216 "rigidSkinIds",
217 &self.m_rigidSkinIds,
218 TypeSize::NonPtr,
219 )?;
220 serializer
221 .serialize_array_field(
222 "externalEventIds",
223 &self.m_externalEventIds,
224 TypeSize::NonPtr,
225 )?;
226 serializer
227 .serialize_array_field(
228 "auxiliaryInfo",
229 &self.m_auxiliaryInfo,
230 TypeSize::NonPtr,
231 )?;
232 serializer
233 .serialize_array_field(
234 "activeEventIds",
235 &self.m_activeEventIds,
236 TypeSize::NonPtr,
237 )?;
238 serializer
239 .serialize_array_field(
240 "activeVariableIds",
241 &self.m_activeVariableIds,
242 TypeSize::NonPtr,
243 )?;
244 serializer.serialize_field("characterId", &self.m_characterId)?;
245 serializer.serialize_field("instanceName", &self.m_instanceName)?;
246 serializer.serialize_field("templateName", &self.m_templateName)?;
247 serializer.serialize_field("fullPathToProject", &self.m_fullPathToProject)?;
248 serializer.serialize_field("behaviorData", &self.m_behaviorData)?;
249 serializer
250 .serialize_field(
251 "behaviorInternalState",
252 &self.m_behaviorInternalState,
253 )?;
254 serializer
255 .skip_field(
256 "nodeIdToInternalStateMap",
257 &self.m_nodeIdToInternalStateMap,
258 )?;
259 serializer.serialize_field("visible", &self.m_visible)?;
260 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
261 serializer
262 .serialize_field(
263 "elapsedSimulationTime",
264 &self.m_elapsedSimulationTime,
265 )?;
266 serializer.serialize_field("skeleton", &self.m_skeleton)?;
267 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
268 serializer.serialize_field("worldFromModel", &self.m_worldFromModel)?;
269 serializer
270 .serialize_array_field(
271 "poseModelSpace",
272 &self.m_poseModelSpace,
273 TypeSize::NonPtr,
274 )?;
275 serializer
276 .serialize_array_field(
277 "rigidAttachmentTransforms",
278 &self.m_rigidAttachmentTransforms,
279 TypeSize::NonPtr,
280 )?;
281 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
282 serializer.end()
283 }
284 }
285};
286#[doc(hidden)]
287#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
288const _: () = {
289 use havok_serde as _serde;
290 #[automatically_derived]
291 impl<'de> _serde::Deserialize<'de> for hkbClientCharacterState<'de> {
292 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
293 where
294 __D: _serde::Deserializer<'de>,
295 {
296 #[allow(non_camel_case_types)]
297 enum __Field {
298 m_deformableSkinIds,
299 m_rigidSkinIds,
300 m_externalEventIds,
301 m_auxiliaryInfo,
302 m_activeEventIds,
303 m_activeVariableIds,
304 m_characterId,
305 m_instanceName,
306 m_templateName,
307 m_fullPathToProject,
308 m_behaviorData,
309 m_behaviorInternalState,
310 m_visible,
311 m_elapsedSimulationTime,
312 m_skeleton,
313 m_worldFromModel,
314 m_poseModelSpace,
315 m_rigidAttachmentTransforms,
316 __ignore,
317 }
318 struct __FieldVisitor;
319 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
320 type Value = __Field;
321 fn expecting(
322 &self,
323 __formatter: &mut core::fmt::Formatter,
324 ) -> core::fmt::Result {
325 core::fmt::Formatter::write_str(__formatter, "field identifier")
326 }
327 #[allow(clippy::match_single_binding)]
329 #[allow(clippy::reversed_empty_ranges)]
330 #[allow(clippy::single_match)]
331 fn visit_key<__E>(
332 self,
333 __value: &str,
334 ) -> core::result::Result<Self::Value, __E>
335 where
336 __E: _serde::de::Error,
337 {
338 match __value {
339 "deformableSkinIds" => Ok(__Field::m_deformableSkinIds),
340 "rigidSkinIds" => Ok(__Field::m_rigidSkinIds),
341 "externalEventIds" => Ok(__Field::m_externalEventIds),
342 "auxiliaryInfo" => Ok(__Field::m_auxiliaryInfo),
343 "activeEventIds" => Ok(__Field::m_activeEventIds),
344 "activeVariableIds" => Ok(__Field::m_activeVariableIds),
345 "characterId" => Ok(__Field::m_characterId),
346 "instanceName" => Ok(__Field::m_instanceName),
347 "templateName" => Ok(__Field::m_templateName),
348 "fullPathToProject" => Ok(__Field::m_fullPathToProject),
349 "behaviorData" => Ok(__Field::m_behaviorData),
350 "behaviorInternalState" => Ok(__Field::m_behaviorInternalState),
351 "visible" => Ok(__Field::m_visible),
352 "elapsedSimulationTime" => Ok(__Field::m_elapsedSimulationTime),
353 "skeleton" => Ok(__Field::m_skeleton),
354 "worldFromModel" => Ok(__Field::m_worldFromModel),
355 "poseModelSpace" => Ok(__Field::m_poseModelSpace),
356 "rigidAttachmentTransforms" => {
357 Ok(__Field::m_rigidAttachmentTransforms)
358 }
359 _ => Ok(__Field::__ignore),
360 }
361 }
362 }
363 impl<'de> _serde::Deserialize<'de> for __Field {
364 #[inline]
365 fn deserialize<__D>(
366 __deserializer: __D,
367 ) -> core::result::Result<Self, __D::Error>
368 where
369 __D: _serde::Deserializer<'de>,
370 {
371 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
372 }
373 }
374 struct __hkbClientCharacterStateVisitor<'de> {
375 marker: _serde::__private::PhantomData<hkbClientCharacterState<'de>>,
376 lifetime: _serde::__private::PhantomData<&'de ()>,
377 }
378 #[allow(clippy::match_single_binding)]
379 #[allow(clippy::reversed_empty_ranges)]
380 #[allow(clippy::single_match)]
381 impl<'de> _serde::de::Visitor<'de>
382 for __hkbClientCharacterStateVisitor<'de> {
383 type Value = hkbClientCharacterState<'de>;
384 fn expecting(
385 &self,
386 __formatter: &mut core::fmt::Formatter,
387 ) -> core::fmt::Result {
388 core::fmt::Formatter::write_str(
389 __formatter,
390 "struct hkbClientCharacterState",
391 )
392 }
393 fn visit_struct_for_bytes<__A>(
394 self,
395 mut __map: __A,
396 ) -> _serde::__private::Result<Self::Value, __A::Error>
397 where
398 __A: _serde::de::MapAccess<'de>,
399 {
400 let __ptr = __A::class_ptr(&mut __map);
401 let parent = __A::parent_value(&mut __map)?;
402 let mut m_deformableSkinIds: _serde::__private::Option<Vec<u64>> = _serde::__private::None;
403 let mut m_rigidSkinIds: _serde::__private::Option<Vec<u64>> = _serde::__private::None;
404 let mut m_externalEventIds: _serde::__private::Option<Vec<i16>> = _serde::__private::None;
405 let mut m_auxiliaryInfo: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
406 let mut m_activeEventIds: _serde::__private::Option<Vec<i16>> = _serde::__private::None;
407 let mut m_activeVariableIds: _serde::__private::Option<Vec<i16>> = _serde::__private::None;
408 let mut m_characterId: _serde::__private::Option<u64> = _serde::__private::None;
409 let mut m_instanceName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
410 let mut m_templateName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
411 let mut m_fullPathToProject: _serde::__private::Option<
412 StringPtr<'de>,
413 > = _serde::__private::None;
414 let mut m_behaviorData: _serde::__private::Option<Pointer> = _serde::__private::None;
415 let mut m_behaviorInternalState: _serde::__private::Option<
416 Pointer,
417 > = _serde::__private::None;
418 let mut m_nodeIdToInternalStateMap: _serde::__private::Option<
419 Pointer,
420 > = _serde::__private::None;
421 let mut m_visible: _serde::__private::Option<bool> = _serde::__private::None;
422 let mut m_elapsedSimulationTime: _serde::__private::Option<f32> = _serde::__private::None;
423 let mut m_skeleton: _serde::__private::Option<Pointer> = _serde::__private::None;
424 let mut m_worldFromModel: _serde::__private::Option<QsTransform> = _serde::__private::None;
425 let mut m_poseModelSpace: _serde::__private::Option<
426 Vec<QsTransform>,
427 > = _serde::__private::None;
428 let mut m_rigidAttachmentTransforms: _serde::__private::Option<
429 Vec<QsTransform>,
430 > = _serde::__private::None;
431 for i in 0..19usize {
432 match i {
433 0usize => {
434 if _serde::__private::Option::is_some(
435 &m_deformableSkinIds,
436 ) {
437 return _serde::__private::Err(
438 <__A::Error as _serde::de::Error>::duplicate_field(
439 "deformableSkinIds",
440 ),
441 );
442 }
443 m_deformableSkinIds = _serde::__private::Some(
444 match __A::next_value::<Vec<u64>>(&mut __map) {
445 _serde::__private::Ok(__val) => __val,
446 _serde::__private::Err(__err) => {
447 return _serde::__private::Err(__err);
448 }
449 },
450 );
451 }
452 1usize => {
453 if _serde::__private::Option::is_some(&m_rigidSkinIds) {
454 return _serde::__private::Err(
455 <__A::Error as _serde::de::Error>::duplicate_field(
456 "rigidSkinIds",
457 ),
458 );
459 }
460 m_rigidSkinIds = _serde::__private::Some(
461 match __A::next_value::<Vec<u64>>(&mut __map) {
462 _serde::__private::Ok(__val) => __val,
463 _serde::__private::Err(__err) => {
464 return _serde::__private::Err(__err);
465 }
466 },
467 );
468 }
469 2usize => {
470 if _serde::__private::Option::is_some(&m_externalEventIds) {
471 return _serde::__private::Err(
472 <__A::Error as _serde::de::Error>::duplicate_field(
473 "externalEventIds",
474 ),
475 );
476 }
477 m_externalEventIds = _serde::__private::Some(
478 match __A::next_value::<Vec<i16>>(&mut __map) {
479 _serde::__private::Ok(__val) => __val,
480 _serde::__private::Err(__err) => {
481 return _serde::__private::Err(__err);
482 }
483 },
484 );
485 }
486 3usize => {
487 if _serde::__private::Option::is_some(&m_auxiliaryInfo) {
488 return _serde::__private::Err(
489 <__A::Error as _serde::de::Error>::duplicate_field(
490 "auxiliaryInfo",
491 ),
492 );
493 }
494 m_auxiliaryInfo = _serde::__private::Some(
495 match __A::next_value::<Vec<Pointer>>(&mut __map) {
496 _serde::__private::Ok(__val) => __val,
497 _serde::__private::Err(__err) => {
498 return _serde::__private::Err(__err);
499 }
500 },
501 );
502 }
503 4usize => {
504 if _serde::__private::Option::is_some(&m_activeEventIds) {
505 return _serde::__private::Err(
506 <__A::Error as _serde::de::Error>::duplicate_field(
507 "activeEventIds",
508 ),
509 );
510 }
511 m_activeEventIds = _serde::__private::Some(
512 match __A::next_value::<Vec<i16>>(&mut __map) {
513 _serde::__private::Ok(__val) => __val,
514 _serde::__private::Err(__err) => {
515 return _serde::__private::Err(__err);
516 }
517 },
518 );
519 }
520 5usize => {
521 if _serde::__private::Option::is_some(
522 &m_activeVariableIds,
523 ) {
524 return _serde::__private::Err(
525 <__A::Error as _serde::de::Error>::duplicate_field(
526 "activeVariableIds",
527 ),
528 );
529 }
530 m_activeVariableIds = _serde::__private::Some(
531 match __A::next_value::<Vec<i16>>(&mut __map) {
532 _serde::__private::Ok(__val) => __val,
533 _serde::__private::Err(__err) => {
534 return _serde::__private::Err(__err);
535 }
536 },
537 );
538 }
539 6usize => {
540 if _serde::__private::Option::is_some(&m_characterId) {
541 return _serde::__private::Err(
542 <__A::Error as _serde::de::Error>::duplicate_field(
543 "characterId",
544 ),
545 );
546 }
547 m_characterId = _serde::__private::Some(
548 match __A::next_value::<u64>(&mut __map) {
549 _serde::__private::Ok(__val) => __val,
550 _serde::__private::Err(__err) => {
551 return _serde::__private::Err(__err);
552 }
553 },
554 );
555 }
556 7usize => {
557 if _serde::__private::Option::is_some(&m_instanceName) {
558 return _serde::__private::Err(
559 <__A::Error as _serde::de::Error>::duplicate_field(
560 "instanceName",
561 ),
562 );
563 }
564 m_instanceName = _serde::__private::Some(
565 match __A::next_value::<StringPtr<'de>>(&mut __map) {
566 _serde::__private::Ok(__val) => __val,
567 _serde::__private::Err(__err) => {
568 return _serde::__private::Err(__err);
569 }
570 },
571 );
572 }
573 8usize => {
574 if _serde::__private::Option::is_some(&m_templateName) {
575 return _serde::__private::Err(
576 <__A::Error as _serde::de::Error>::duplicate_field(
577 "templateName",
578 ),
579 );
580 }
581 m_templateName = _serde::__private::Some(
582 match __A::next_value::<StringPtr<'de>>(&mut __map) {
583 _serde::__private::Ok(__val) => __val,
584 _serde::__private::Err(__err) => {
585 return _serde::__private::Err(__err);
586 }
587 },
588 );
589 }
590 9usize => {
591 if _serde::__private::Option::is_some(
592 &m_fullPathToProject,
593 ) {
594 return _serde::__private::Err(
595 <__A::Error as _serde::de::Error>::duplicate_field(
596 "fullPathToProject",
597 ),
598 );
599 }
600 m_fullPathToProject = _serde::__private::Some(
601 match __A::next_value::<StringPtr<'de>>(&mut __map) {
602 _serde::__private::Ok(__val) => __val,
603 _serde::__private::Err(__err) => {
604 return _serde::__private::Err(__err);
605 }
606 },
607 );
608 }
609 10usize => {
610 if _serde::__private::Option::is_some(&m_behaviorData) {
611 return _serde::__private::Err(
612 <__A::Error as _serde::de::Error>::duplicate_field(
613 "behaviorData",
614 ),
615 );
616 }
617 m_behaviorData = _serde::__private::Some(
618 match __A::next_value::<Pointer>(&mut __map) {
619 _serde::__private::Ok(__val) => __val,
620 _serde::__private::Err(__err) => {
621 return _serde::__private::Err(__err);
622 }
623 },
624 );
625 }
626 11usize => {
627 if _serde::__private::Option::is_some(
628 &m_behaviorInternalState,
629 ) {
630 return _serde::__private::Err(
631 <__A::Error as _serde::de::Error>::duplicate_field(
632 "behaviorInternalState",
633 ),
634 );
635 }
636 m_behaviorInternalState = _serde::__private::Some(
637 match __A::next_value::<Pointer>(&mut __map) {
638 _serde::__private::Ok(__val) => __val,
639 _serde::__private::Err(__err) => {
640 return _serde::__private::Err(__err);
641 }
642 },
643 );
644 }
645 12usize => {
646 if _serde::__private::Option::is_some(
647 &m_nodeIdToInternalStateMap,
648 ) {
649 return _serde::__private::Err(
650 <__A::Error as _serde::de::Error>::duplicate_field(
651 "nodeIdToInternalStateMap",
652 ),
653 );
654 }
655 m_nodeIdToInternalStateMap = _serde::__private::Some(
656 match __A::next_value::<Pointer>(&mut __map) {
657 _serde::__private::Ok(__val) => __val,
658 _serde::__private::Err(__err) => {
659 return _serde::__private::Err(__err);
660 }
661 },
662 );
663 }
664 13usize => {
665 if _serde::__private::Option::is_some(&m_visible) {
666 return _serde::__private::Err(
667 <__A::Error as _serde::de::Error>::duplicate_field(
668 "visible",
669 ),
670 );
671 }
672 m_visible = _serde::__private::Some(
673 match __A::next_value::<bool>(&mut __map) {
674 _serde::__private::Ok(__val) => __val,
675 _serde::__private::Err(__err) => {
676 return _serde::__private::Err(__err);
677 }
678 },
679 );
680 }
681 14usize => {
682 if _serde::__private::Option::is_some(
683 &m_elapsedSimulationTime,
684 ) {
685 return _serde::__private::Err(
686 <__A::Error as _serde::de::Error>::duplicate_field(
687 "elapsedSimulationTime",
688 ),
689 );
690 }
691 __A::pad(&mut __map, 3usize, 3usize)?;
692 m_elapsedSimulationTime = _serde::__private::Some(
693 match __A::next_value::<f32>(&mut __map) {
694 _serde::__private::Ok(__val) => __val,
695 _serde::__private::Err(__err) => {
696 return _serde::__private::Err(__err);
697 }
698 },
699 );
700 }
701 15usize => {
702 if _serde::__private::Option::is_some(&m_skeleton) {
703 return _serde::__private::Err(
704 <__A::Error as _serde::de::Error>::duplicate_field(
705 "skeleton",
706 ),
707 );
708 }
709 m_skeleton = _serde::__private::Some(
710 match __A::next_value::<Pointer>(&mut __map) {
711 _serde::__private::Ok(__val) => __val,
712 _serde::__private::Err(__err) => {
713 return _serde::__private::Err(__err);
714 }
715 },
716 );
717 }
718 16usize => {
719 if _serde::__private::Option::is_some(&m_worldFromModel) {
720 return _serde::__private::Err(
721 <__A::Error as _serde::de::Error>::duplicate_field(
722 "worldFromModel",
723 ),
724 );
725 }
726 __A::pad(&mut __map, 4usize, 8usize)?;
727 m_worldFromModel = _serde::__private::Some(
728 match __A::next_value::<QsTransform>(&mut __map) {
729 _serde::__private::Ok(__val) => __val,
730 _serde::__private::Err(__err) => {
731 return _serde::__private::Err(__err);
732 }
733 },
734 );
735 }
736 17usize => {
737 if _serde::__private::Option::is_some(&m_poseModelSpace) {
738 return _serde::__private::Err(
739 <__A::Error as _serde::de::Error>::duplicate_field(
740 "poseModelSpace",
741 ),
742 );
743 }
744 m_poseModelSpace = _serde::__private::Some(
745 match __A::next_value::<Vec<QsTransform>>(&mut __map) {
746 _serde::__private::Ok(__val) => __val,
747 _serde::__private::Err(__err) => {
748 return _serde::__private::Err(__err);
749 }
750 },
751 );
752 }
753 18usize => {
754 if _serde::__private::Option::is_some(
755 &m_rigidAttachmentTransforms,
756 ) {
757 return _serde::__private::Err(
758 <__A::Error as _serde::de::Error>::duplicate_field(
759 "rigidAttachmentTransforms",
760 ),
761 );
762 }
763 m_rigidAttachmentTransforms = _serde::__private::Some(
764 match __A::next_value::<Vec<QsTransform>>(&mut __map) {
765 _serde::__private::Ok(__val) => __val,
766 _serde::__private::Err(__err) => {
767 return _serde::__private::Err(__err);
768 }
769 },
770 );
771 }
772 _ => {}
773 }
774 }
775 __A::pad(&mut __map, 8usize, 0usize)?;
776 let m_deformableSkinIds = match m_deformableSkinIds {
777 _serde::__private::Some(__field) => __field,
778 _serde::__private::None => {
779 return _serde::__private::Err(
780 <__A::Error as _serde::de::Error>::missing_field(
781 "deformableSkinIds",
782 ),
783 );
784 }
785 };
786 let m_rigidSkinIds = match m_rigidSkinIds {
787 _serde::__private::Some(__field) => __field,
788 _serde::__private::None => {
789 return _serde::__private::Err(
790 <__A::Error as _serde::de::Error>::missing_field(
791 "rigidSkinIds",
792 ),
793 );
794 }
795 };
796 let m_externalEventIds = match m_externalEventIds {
797 _serde::__private::Some(__field) => __field,
798 _serde::__private::None => {
799 return _serde::__private::Err(
800 <__A::Error as _serde::de::Error>::missing_field(
801 "externalEventIds",
802 ),
803 );
804 }
805 };
806 let m_auxiliaryInfo = match m_auxiliaryInfo {
807 _serde::__private::Some(__field) => __field,
808 _serde::__private::None => {
809 return _serde::__private::Err(
810 <__A::Error as _serde::de::Error>::missing_field(
811 "auxiliaryInfo",
812 ),
813 );
814 }
815 };
816 let m_activeEventIds = match m_activeEventIds {
817 _serde::__private::Some(__field) => __field,
818 _serde::__private::None => {
819 return _serde::__private::Err(
820 <__A::Error as _serde::de::Error>::missing_field(
821 "activeEventIds",
822 ),
823 );
824 }
825 };
826 let m_activeVariableIds = match m_activeVariableIds {
827 _serde::__private::Some(__field) => __field,
828 _serde::__private::None => {
829 return _serde::__private::Err(
830 <__A::Error as _serde::de::Error>::missing_field(
831 "activeVariableIds",
832 ),
833 );
834 }
835 };
836 let m_characterId = match m_characterId {
837 _serde::__private::Some(__field) => __field,
838 _serde::__private::None => {
839 return _serde::__private::Err(
840 <__A::Error as _serde::de::Error>::missing_field(
841 "characterId",
842 ),
843 );
844 }
845 };
846 let m_instanceName = match m_instanceName {
847 _serde::__private::Some(__field) => __field,
848 _serde::__private::None => {
849 return _serde::__private::Err(
850 <__A::Error as _serde::de::Error>::missing_field(
851 "instanceName",
852 ),
853 );
854 }
855 };
856 let m_templateName = match m_templateName {
857 _serde::__private::Some(__field) => __field,
858 _serde::__private::None => {
859 return _serde::__private::Err(
860 <__A::Error as _serde::de::Error>::missing_field(
861 "templateName",
862 ),
863 );
864 }
865 };
866 let m_fullPathToProject = match m_fullPathToProject {
867 _serde::__private::Some(__field) => __field,
868 _serde::__private::None => {
869 return _serde::__private::Err(
870 <__A::Error as _serde::de::Error>::missing_field(
871 "fullPathToProject",
872 ),
873 );
874 }
875 };
876 let m_behaviorData = match m_behaviorData {
877 _serde::__private::Some(__field) => __field,
878 _serde::__private::None => {
879 return _serde::__private::Err(
880 <__A::Error as _serde::de::Error>::missing_field(
881 "behaviorData",
882 ),
883 );
884 }
885 };
886 let m_behaviorInternalState = match m_behaviorInternalState {
887 _serde::__private::Some(__field) => __field,
888 _serde::__private::None => {
889 return _serde::__private::Err(
890 <__A::Error as _serde::de::Error>::missing_field(
891 "behaviorInternalState",
892 ),
893 );
894 }
895 };
896 let m_nodeIdToInternalStateMap = match m_nodeIdToInternalStateMap {
897 _serde::__private::Some(__field) => __field,
898 _serde::__private::None => {
899 return _serde::__private::Err(
900 <__A::Error as _serde::de::Error>::missing_field(
901 "nodeIdToInternalStateMap",
902 ),
903 );
904 }
905 };
906 let m_visible = match m_visible {
907 _serde::__private::Some(__field) => __field,
908 _serde::__private::None => {
909 return _serde::__private::Err(
910 <__A::Error as _serde::de::Error>::missing_field("visible"),
911 );
912 }
913 };
914 let m_elapsedSimulationTime = match m_elapsedSimulationTime {
915 _serde::__private::Some(__field) => __field,
916 _serde::__private::None => {
917 return _serde::__private::Err(
918 <__A::Error as _serde::de::Error>::missing_field(
919 "elapsedSimulationTime",
920 ),
921 );
922 }
923 };
924 let m_skeleton = match m_skeleton {
925 _serde::__private::Some(__field) => __field,
926 _serde::__private::None => {
927 return _serde::__private::Err(
928 <__A::Error as _serde::de::Error>::missing_field("skeleton"),
929 );
930 }
931 };
932 let m_worldFromModel = match m_worldFromModel {
933 _serde::__private::Some(__field) => __field,
934 _serde::__private::None => {
935 return _serde::__private::Err(
936 <__A::Error as _serde::de::Error>::missing_field(
937 "worldFromModel",
938 ),
939 );
940 }
941 };
942 let m_poseModelSpace = match m_poseModelSpace {
943 _serde::__private::Some(__field) => __field,
944 _serde::__private::None => {
945 return _serde::__private::Err(
946 <__A::Error as _serde::de::Error>::missing_field(
947 "poseModelSpace",
948 ),
949 );
950 }
951 };
952 let m_rigidAttachmentTransforms = match m_rigidAttachmentTransforms {
953 _serde::__private::Some(__field) => __field,
954 _serde::__private::None => {
955 return _serde::__private::Err(
956 <__A::Error as _serde::de::Error>::missing_field(
957 "rigidAttachmentTransforms",
958 ),
959 );
960 }
961 };
962 _serde::__private::Ok(hkbClientCharacterState {
963 __ptr,
964 parent,
965 m_deformableSkinIds,
966 m_rigidSkinIds,
967 m_externalEventIds,
968 m_auxiliaryInfo,
969 m_activeEventIds,
970 m_activeVariableIds,
971 m_characterId,
972 m_instanceName,
973 m_templateName,
974 m_fullPathToProject,
975 m_behaviorData,
976 m_behaviorInternalState,
977 m_nodeIdToInternalStateMap,
978 m_visible,
979 m_elapsedSimulationTime,
980 m_skeleton,
981 m_worldFromModel,
982 m_poseModelSpace,
983 m_rigidAttachmentTransforms,
984 })
985 }
986 #[allow(clippy::manual_unwrap_or_default)]
987 fn visit_struct<__A>(
988 self,
989 mut __map: __A,
990 ) -> _serde::__private::Result<Self::Value, __A::Error>
991 where
992 __A: _serde::de::MapAccess<'de>,
993 {
994 let mut m_deformableSkinIds: _serde::__private::Option<Vec<u64>> = _serde::__private::None;
995 let mut m_rigidSkinIds: _serde::__private::Option<Vec<u64>> = _serde::__private::None;
996 let mut m_externalEventIds: _serde::__private::Option<Vec<i16>> = _serde::__private::None;
997 let mut m_auxiliaryInfo: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
998 let mut m_activeEventIds: _serde::__private::Option<Vec<i16>> = _serde::__private::None;
999 let mut m_activeVariableIds: _serde::__private::Option<Vec<i16>> = _serde::__private::None;
1000 let mut m_characterId: _serde::__private::Option<u64> = _serde::__private::None;
1001 let mut m_instanceName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1002 let mut m_templateName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1003 let mut m_fullPathToProject: _serde::__private::Option<
1004 StringPtr<'de>,
1005 > = _serde::__private::None;
1006 let mut m_behaviorData: _serde::__private::Option<Pointer> = _serde::__private::None;
1007 let mut m_behaviorInternalState: _serde::__private::Option<
1008 Pointer,
1009 > = _serde::__private::None;
1010 let mut m_visible: _serde::__private::Option<bool> = _serde::__private::None;
1011 let mut m_elapsedSimulationTime: _serde::__private::Option<f32> = _serde::__private::None;
1012 let mut m_skeleton: _serde::__private::Option<Pointer> = _serde::__private::None;
1013 let mut m_worldFromModel: _serde::__private::Option<QsTransform> = _serde::__private::None;
1014 let mut m_poseModelSpace: _serde::__private::Option<
1015 Vec<QsTransform>,
1016 > = _serde::__private::None;
1017 let mut m_rigidAttachmentTransforms: _serde::__private::Option<
1018 Vec<QsTransform>,
1019 > = _serde::__private::None;
1020 while let _serde::__private::Some(__key) = {
1021 __A::next_key::<__Field>(&mut __map)?
1022 } {
1023 match __key {
1024 __Field::m_deformableSkinIds => {
1025 #[cfg(
1026 any(feature = "strict", feature = "ignore_duplicates")
1027 )]
1028 if _serde::__private::Option::is_some(
1029 &m_deformableSkinIds,
1030 ) {
1031 #[cfg(feature = "ignore_duplicates")]
1032 {
1033 __A::skip_value(&mut __map)?;
1034 continue;
1035 }
1036 #[cfg(feature = "strict")]
1037 return _serde::__private::Err(
1038 <__A::Error as _serde::de::Error>::duplicate_field(
1039 "deformableSkinIds",
1040 ),
1041 );
1042 }
1043 m_deformableSkinIds = _serde::__private::Some(
1044 match __A::next_value::<Vec<u64>>(&mut __map) {
1045 _serde::__private::Ok(__val) => __val,
1046 _serde::__private::Err(__err) => {
1047 return _serde::__private::Err(__err);
1048 }
1049 },
1050 );
1051 }
1052 __Field::m_rigidSkinIds => {
1053 #[cfg(
1054 any(feature = "strict", feature = "ignore_duplicates")
1055 )]
1056 if _serde::__private::Option::is_some(&m_rigidSkinIds) {
1057 #[cfg(feature = "ignore_duplicates")]
1058 {
1059 __A::skip_value(&mut __map)?;
1060 continue;
1061 }
1062 #[cfg(feature = "strict")]
1063 return _serde::__private::Err(
1064 <__A::Error as _serde::de::Error>::duplicate_field(
1065 "rigidSkinIds",
1066 ),
1067 );
1068 }
1069 m_rigidSkinIds = _serde::__private::Some(
1070 match __A::next_value::<Vec<u64>>(&mut __map) {
1071 _serde::__private::Ok(__val) => __val,
1072 _serde::__private::Err(__err) => {
1073 return _serde::__private::Err(__err);
1074 }
1075 },
1076 );
1077 }
1078 __Field::m_externalEventIds => {
1079 #[cfg(
1080 any(feature = "strict", feature = "ignore_duplicates")
1081 )]
1082 if _serde::__private::Option::is_some(&m_externalEventIds) {
1083 #[cfg(feature = "ignore_duplicates")]
1084 {
1085 __A::skip_value(&mut __map)?;
1086 continue;
1087 }
1088 #[cfg(feature = "strict")]
1089 return _serde::__private::Err(
1090 <__A::Error as _serde::de::Error>::duplicate_field(
1091 "externalEventIds",
1092 ),
1093 );
1094 }
1095 m_externalEventIds = _serde::__private::Some(
1096 match __A::next_value::<Vec<i16>>(&mut __map) {
1097 _serde::__private::Ok(__val) => __val,
1098 _serde::__private::Err(__err) => {
1099 return _serde::__private::Err(__err);
1100 }
1101 },
1102 );
1103 }
1104 __Field::m_auxiliaryInfo => {
1105 #[cfg(
1106 any(feature = "strict", feature = "ignore_duplicates")
1107 )]
1108 if _serde::__private::Option::is_some(&m_auxiliaryInfo) {
1109 #[cfg(feature = "ignore_duplicates")]
1110 {
1111 __A::skip_value(&mut __map)?;
1112 continue;
1113 }
1114 #[cfg(feature = "strict")]
1115 return _serde::__private::Err(
1116 <__A::Error as _serde::de::Error>::duplicate_field(
1117 "auxiliaryInfo",
1118 ),
1119 );
1120 }
1121 m_auxiliaryInfo = _serde::__private::Some(
1122 match __A::next_value::<Vec<Pointer>>(&mut __map) {
1123 _serde::__private::Ok(__val) => __val,
1124 _serde::__private::Err(__err) => {
1125 return _serde::__private::Err(__err);
1126 }
1127 },
1128 );
1129 }
1130 __Field::m_activeEventIds => {
1131 #[cfg(
1132 any(feature = "strict", feature = "ignore_duplicates")
1133 )]
1134 if _serde::__private::Option::is_some(&m_activeEventIds) {
1135 #[cfg(feature = "ignore_duplicates")]
1136 {
1137 __A::skip_value(&mut __map)?;
1138 continue;
1139 }
1140 #[cfg(feature = "strict")]
1141 return _serde::__private::Err(
1142 <__A::Error as _serde::de::Error>::duplicate_field(
1143 "activeEventIds",
1144 ),
1145 );
1146 }
1147 m_activeEventIds = _serde::__private::Some(
1148 match __A::next_value::<Vec<i16>>(&mut __map) {
1149 _serde::__private::Ok(__val) => __val,
1150 _serde::__private::Err(__err) => {
1151 return _serde::__private::Err(__err);
1152 }
1153 },
1154 );
1155 }
1156 __Field::m_activeVariableIds => {
1157 #[cfg(
1158 any(feature = "strict", feature = "ignore_duplicates")
1159 )]
1160 if _serde::__private::Option::is_some(
1161 &m_activeVariableIds,
1162 ) {
1163 #[cfg(feature = "ignore_duplicates")]
1164 {
1165 __A::skip_value(&mut __map)?;
1166 continue;
1167 }
1168 #[cfg(feature = "strict")]
1169 return _serde::__private::Err(
1170 <__A::Error as _serde::de::Error>::duplicate_field(
1171 "activeVariableIds",
1172 ),
1173 );
1174 }
1175 m_activeVariableIds = _serde::__private::Some(
1176 match __A::next_value::<Vec<i16>>(&mut __map) {
1177 _serde::__private::Ok(__val) => __val,
1178 _serde::__private::Err(__err) => {
1179 return _serde::__private::Err(__err);
1180 }
1181 },
1182 );
1183 }
1184 __Field::m_characterId => {
1185 #[cfg(
1186 any(feature = "strict", feature = "ignore_duplicates")
1187 )]
1188 if _serde::__private::Option::is_some(&m_characterId) {
1189 #[cfg(feature = "ignore_duplicates")]
1190 {
1191 __A::skip_value(&mut __map)?;
1192 continue;
1193 }
1194 #[cfg(feature = "strict")]
1195 return _serde::__private::Err(
1196 <__A::Error as _serde::de::Error>::duplicate_field(
1197 "characterId",
1198 ),
1199 );
1200 }
1201 m_characterId = _serde::__private::Some(
1202 match __A::next_value::<u64>(&mut __map) {
1203 _serde::__private::Ok(__val) => __val,
1204 _serde::__private::Err(__err) => {
1205 return _serde::__private::Err(__err);
1206 }
1207 },
1208 );
1209 }
1210 __Field::m_instanceName => {
1211 #[cfg(
1212 any(feature = "strict", feature = "ignore_duplicates")
1213 )]
1214 if _serde::__private::Option::is_some(&m_instanceName) {
1215 #[cfg(feature = "ignore_duplicates")]
1216 {
1217 __A::skip_value(&mut __map)?;
1218 continue;
1219 }
1220 #[cfg(feature = "strict")]
1221 return _serde::__private::Err(
1222 <__A::Error as _serde::de::Error>::duplicate_field(
1223 "instanceName",
1224 ),
1225 );
1226 }
1227 m_instanceName = _serde::__private::Some(
1228 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1229 _serde::__private::Ok(__val) => __val,
1230 _serde::__private::Err(__err) => {
1231 return _serde::__private::Err(__err);
1232 }
1233 },
1234 );
1235 }
1236 __Field::m_templateName => {
1237 #[cfg(
1238 any(feature = "strict", feature = "ignore_duplicates")
1239 )]
1240 if _serde::__private::Option::is_some(&m_templateName) {
1241 #[cfg(feature = "ignore_duplicates")]
1242 {
1243 __A::skip_value(&mut __map)?;
1244 continue;
1245 }
1246 #[cfg(feature = "strict")]
1247 return _serde::__private::Err(
1248 <__A::Error as _serde::de::Error>::duplicate_field(
1249 "templateName",
1250 ),
1251 );
1252 }
1253 m_templateName = _serde::__private::Some(
1254 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1255 _serde::__private::Ok(__val) => __val,
1256 _serde::__private::Err(__err) => {
1257 return _serde::__private::Err(__err);
1258 }
1259 },
1260 );
1261 }
1262 __Field::m_fullPathToProject => {
1263 #[cfg(
1264 any(feature = "strict", feature = "ignore_duplicates")
1265 )]
1266 if _serde::__private::Option::is_some(
1267 &m_fullPathToProject,
1268 ) {
1269 #[cfg(feature = "ignore_duplicates")]
1270 {
1271 __A::skip_value(&mut __map)?;
1272 continue;
1273 }
1274 #[cfg(feature = "strict")]
1275 return _serde::__private::Err(
1276 <__A::Error as _serde::de::Error>::duplicate_field(
1277 "fullPathToProject",
1278 ),
1279 );
1280 }
1281 m_fullPathToProject = _serde::__private::Some(
1282 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1283 _serde::__private::Ok(__val) => __val,
1284 _serde::__private::Err(__err) => {
1285 return _serde::__private::Err(__err);
1286 }
1287 },
1288 );
1289 }
1290 __Field::m_behaviorData => {
1291 #[cfg(
1292 any(feature = "strict", feature = "ignore_duplicates")
1293 )]
1294 if _serde::__private::Option::is_some(&m_behaviorData) {
1295 #[cfg(feature = "ignore_duplicates")]
1296 {
1297 __A::skip_value(&mut __map)?;
1298 continue;
1299 }
1300 #[cfg(feature = "strict")]
1301 return _serde::__private::Err(
1302 <__A::Error as _serde::de::Error>::duplicate_field(
1303 "behaviorData",
1304 ),
1305 );
1306 }
1307 m_behaviorData = _serde::__private::Some(
1308 match __A::next_value::<Pointer>(&mut __map) {
1309 _serde::__private::Ok(__val) => __val,
1310 _serde::__private::Err(__err) => {
1311 return _serde::__private::Err(__err);
1312 }
1313 },
1314 );
1315 }
1316 __Field::m_behaviorInternalState => {
1317 #[cfg(
1318 any(feature = "strict", feature = "ignore_duplicates")
1319 )]
1320 if _serde::__private::Option::is_some(
1321 &m_behaviorInternalState,
1322 ) {
1323 #[cfg(feature = "ignore_duplicates")]
1324 {
1325 __A::skip_value(&mut __map)?;
1326 continue;
1327 }
1328 #[cfg(feature = "strict")]
1329 return _serde::__private::Err(
1330 <__A::Error as _serde::de::Error>::duplicate_field(
1331 "behaviorInternalState",
1332 ),
1333 );
1334 }
1335 m_behaviorInternalState = _serde::__private::Some(
1336 match __A::next_value::<Pointer>(&mut __map) {
1337 _serde::__private::Ok(__val) => __val,
1338 _serde::__private::Err(__err) => {
1339 return _serde::__private::Err(__err);
1340 }
1341 },
1342 );
1343 }
1344 __Field::m_visible => {
1345 #[cfg(
1346 any(feature = "strict", feature = "ignore_duplicates")
1347 )]
1348 if _serde::__private::Option::is_some(&m_visible) {
1349 #[cfg(feature = "ignore_duplicates")]
1350 {
1351 __A::skip_value(&mut __map)?;
1352 continue;
1353 }
1354 #[cfg(feature = "strict")]
1355 return _serde::__private::Err(
1356 <__A::Error as _serde::de::Error>::duplicate_field(
1357 "visible",
1358 ),
1359 );
1360 }
1361 m_visible = _serde::__private::Some(
1362 match __A::next_value::<bool>(&mut __map) {
1363 _serde::__private::Ok(__val) => __val,
1364 _serde::__private::Err(__err) => {
1365 return _serde::__private::Err(__err);
1366 }
1367 },
1368 );
1369 }
1370 __Field::m_elapsedSimulationTime => {
1371 #[cfg(
1372 any(feature = "strict", feature = "ignore_duplicates")
1373 )]
1374 if _serde::__private::Option::is_some(
1375 &m_elapsedSimulationTime,
1376 ) {
1377 #[cfg(feature = "ignore_duplicates")]
1378 {
1379 __A::skip_value(&mut __map)?;
1380 continue;
1381 }
1382 #[cfg(feature = "strict")]
1383 return _serde::__private::Err(
1384 <__A::Error as _serde::de::Error>::duplicate_field(
1385 "elapsedSimulationTime",
1386 ),
1387 );
1388 }
1389 m_elapsedSimulationTime = _serde::__private::Some(
1390 match __A::next_value::<f32>(&mut __map) {
1391 _serde::__private::Ok(__val) => __val,
1392 _serde::__private::Err(__err) => {
1393 return _serde::__private::Err(__err);
1394 }
1395 },
1396 );
1397 }
1398 __Field::m_skeleton => {
1399 #[cfg(
1400 any(feature = "strict", feature = "ignore_duplicates")
1401 )]
1402 if _serde::__private::Option::is_some(&m_skeleton) {
1403 #[cfg(feature = "ignore_duplicates")]
1404 {
1405 __A::skip_value(&mut __map)?;
1406 continue;
1407 }
1408 #[cfg(feature = "strict")]
1409 return _serde::__private::Err(
1410 <__A::Error as _serde::de::Error>::duplicate_field(
1411 "skeleton",
1412 ),
1413 );
1414 }
1415 m_skeleton = _serde::__private::Some(
1416 match __A::next_value::<Pointer>(&mut __map) {
1417 _serde::__private::Ok(__val) => __val,
1418 _serde::__private::Err(__err) => {
1419 return _serde::__private::Err(__err);
1420 }
1421 },
1422 );
1423 }
1424 __Field::m_worldFromModel => {
1425 #[cfg(
1426 any(feature = "strict", feature = "ignore_duplicates")
1427 )]
1428 if _serde::__private::Option::is_some(&m_worldFromModel) {
1429 #[cfg(feature = "ignore_duplicates")]
1430 {
1431 __A::skip_value(&mut __map)?;
1432 continue;
1433 }
1434 #[cfg(feature = "strict")]
1435 return _serde::__private::Err(
1436 <__A::Error as _serde::de::Error>::duplicate_field(
1437 "worldFromModel",
1438 ),
1439 );
1440 }
1441 m_worldFromModel = _serde::__private::Some(
1442 match __A::next_value::<QsTransform>(&mut __map) {
1443 _serde::__private::Ok(__val) => __val,
1444 _serde::__private::Err(__err) => {
1445 return _serde::__private::Err(__err);
1446 }
1447 },
1448 );
1449 }
1450 __Field::m_poseModelSpace => {
1451 #[cfg(
1452 any(feature = "strict", feature = "ignore_duplicates")
1453 )]
1454 if _serde::__private::Option::is_some(&m_poseModelSpace) {
1455 #[cfg(feature = "ignore_duplicates")]
1456 {
1457 __A::skip_value(&mut __map)?;
1458 continue;
1459 }
1460 #[cfg(feature = "strict")]
1461 return _serde::__private::Err(
1462 <__A::Error as _serde::de::Error>::duplicate_field(
1463 "poseModelSpace",
1464 ),
1465 );
1466 }
1467 m_poseModelSpace = _serde::__private::Some(
1468 match __A::next_value::<Vec<QsTransform>>(&mut __map) {
1469 _serde::__private::Ok(__val) => __val,
1470 _serde::__private::Err(__err) => {
1471 return _serde::__private::Err(__err);
1472 }
1473 },
1474 );
1475 }
1476 __Field::m_rigidAttachmentTransforms => {
1477 #[cfg(
1478 any(feature = "strict", feature = "ignore_duplicates")
1479 )]
1480 if _serde::__private::Option::is_some(
1481 &m_rigidAttachmentTransforms,
1482 ) {
1483 #[cfg(feature = "ignore_duplicates")]
1484 {
1485 __A::skip_value(&mut __map)?;
1486 continue;
1487 }
1488 #[cfg(feature = "strict")]
1489 return _serde::__private::Err(
1490 <__A::Error as _serde::de::Error>::duplicate_field(
1491 "rigidAttachmentTransforms",
1492 ),
1493 );
1494 }
1495 m_rigidAttachmentTransforms = _serde::__private::Some(
1496 match __A::next_value::<Vec<QsTransform>>(&mut __map) {
1497 _serde::__private::Ok(__val) => __val,
1498 _serde::__private::Err(__err) => {
1499 return _serde::__private::Err(__err);
1500 }
1501 },
1502 );
1503 }
1504 _ => __A::skip_value(&mut __map)?,
1505 }
1506 }
1507 let m_deformableSkinIds = match m_deformableSkinIds {
1508 _serde::__private::Some(__field) => __field,
1509 _serde::__private::None => {
1510 #[cfg(feature = "strict")]
1511 return _serde::__private::Err(
1512 <__A::Error as _serde::de::Error>::missing_field(
1513 "deformableSkinIds",
1514 ),
1515 );
1516 #[cfg(not(feature = "strict"))] Default::default()
1517 }
1518 };
1519 let m_rigidSkinIds = match m_rigidSkinIds {
1520 _serde::__private::Some(__field) => __field,
1521 _serde::__private::None => {
1522 #[cfg(feature = "strict")]
1523 return _serde::__private::Err(
1524 <__A::Error as _serde::de::Error>::missing_field(
1525 "rigidSkinIds",
1526 ),
1527 );
1528 #[cfg(not(feature = "strict"))] Default::default()
1529 }
1530 };
1531 let m_externalEventIds = match m_externalEventIds {
1532 _serde::__private::Some(__field) => __field,
1533 _serde::__private::None => {
1534 #[cfg(feature = "strict")]
1535 return _serde::__private::Err(
1536 <__A::Error as _serde::de::Error>::missing_field(
1537 "externalEventIds",
1538 ),
1539 );
1540 #[cfg(not(feature = "strict"))] Default::default()
1541 }
1542 };
1543 let m_auxiliaryInfo = match m_auxiliaryInfo {
1544 _serde::__private::Some(__field) => __field,
1545 _serde::__private::None => {
1546 #[cfg(feature = "strict")]
1547 return _serde::__private::Err(
1548 <__A::Error as _serde::de::Error>::missing_field(
1549 "auxiliaryInfo",
1550 ),
1551 );
1552 #[cfg(not(feature = "strict"))] Default::default()
1553 }
1554 };
1555 let m_activeEventIds = match m_activeEventIds {
1556 _serde::__private::Some(__field) => __field,
1557 _serde::__private::None => {
1558 #[cfg(feature = "strict")]
1559 return _serde::__private::Err(
1560 <__A::Error as _serde::de::Error>::missing_field(
1561 "activeEventIds",
1562 ),
1563 );
1564 #[cfg(not(feature = "strict"))] Default::default()
1565 }
1566 };
1567 let m_activeVariableIds = match m_activeVariableIds {
1568 _serde::__private::Some(__field) => __field,
1569 _serde::__private::None => {
1570 #[cfg(feature = "strict")]
1571 return _serde::__private::Err(
1572 <__A::Error as _serde::de::Error>::missing_field(
1573 "activeVariableIds",
1574 ),
1575 );
1576 #[cfg(not(feature = "strict"))] Default::default()
1577 }
1578 };
1579 let m_characterId = match m_characterId {
1580 _serde::__private::Some(__field) => __field,
1581 _serde::__private::None => {
1582 #[cfg(feature = "strict")]
1583 return _serde::__private::Err(
1584 <__A::Error as _serde::de::Error>::missing_field(
1585 "characterId",
1586 ),
1587 );
1588 #[cfg(not(feature = "strict"))] Default::default()
1589 }
1590 };
1591 let m_instanceName = match m_instanceName {
1592 _serde::__private::Some(__field) => __field,
1593 _serde::__private::None => {
1594 #[cfg(feature = "strict")]
1595 return _serde::__private::Err(
1596 <__A::Error as _serde::de::Error>::missing_field(
1597 "instanceName",
1598 ),
1599 );
1600 #[cfg(not(feature = "strict"))] Default::default()
1601 }
1602 };
1603 let m_templateName = match m_templateName {
1604 _serde::__private::Some(__field) => __field,
1605 _serde::__private::None => {
1606 #[cfg(feature = "strict")]
1607 return _serde::__private::Err(
1608 <__A::Error as _serde::de::Error>::missing_field(
1609 "templateName",
1610 ),
1611 );
1612 #[cfg(not(feature = "strict"))] Default::default()
1613 }
1614 };
1615 let m_fullPathToProject = match m_fullPathToProject {
1616 _serde::__private::Some(__field) => __field,
1617 _serde::__private::None => {
1618 #[cfg(feature = "strict")]
1619 return _serde::__private::Err(
1620 <__A::Error as _serde::de::Error>::missing_field(
1621 "fullPathToProject",
1622 ),
1623 );
1624 #[cfg(not(feature = "strict"))] Default::default()
1625 }
1626 };
1627 let m_behaviorData = match m_behaviorData {
1628 _serde::__private::Some(__field) => __field,
1629 _serde::__private::None => {
1630 #[cfg(feature = "strict")]
1631 return _serde::__private::Err(
1632 <__A::Error as _serde::de::Error>::missing_field(
1633 "behaviorData",
1634 ),
1635 );
1636 #[cfg(not(feature = "strict"))] Default::default()
1637 }
1638 };
1639 let m_behaviorInternalState = match m_behaviorInternalState {
1640 _serde::__private::Some(__field) => __field,
1641 _serde::__private::None => {
1642 #[cfg(feature = "strict")]
1643 return _serde::__private::Err(
1644 <__A::Error as _serde::de::Error>::missing_field(
1645 "behaviorInternalState",
1646 ),
1647 );
1648 #[cfg(not(feature = "strict"))] Default::default()
1649 }
1650 };
1651 let m_visible = match m_visible {
1652 _serde::__private::Some(__field) => __field,
1653 _serde::__private::None => {
1654 #[cfg(feature = "strict")]
1655 return _serde::__private::Err(
1656 <__A::Error as _serde::de::Error>::missing_field("visible"),
1657 );
1658 #[cfg(not(feature = "strict"))] Default::default()
1659 }
1660 };
1661 let m_elapsedSimulationTime = match m_elapsedSimulationTime {
1662 _serde::__private::Some(__field) => __field,
1663 _serde::__private::None => {
1664 #[cfg(feature = "strict")]
1665 return _serde::__private::Err(
1666 <__A::Error as _serde::de::Error>::missing_field(
1667 "elapsedSimulationTime",
1668 ),
1669 );
1670 #[cfg(not(feature = "strict"))] Default::default()
1671 }
1672 };
1673 let m_skeleton = match m_skeleton {
1674 _serde::__private::Some(__field) => __field,
1675 _serde::__private::None => {
1676 #[cfg(feature = "strict")]
1677 return _serde::__private::Err(
1678 <__A::Error as _serde::de::Error>::missing_field("skeleton"),
1679 );
1680 #[cfg(not(feature = "strict"))] Default::default()
1681 }
1682 };
1683 let m_worldFromModel = match m_worldFromModel {
1684 _serde::__private::Some(__field) => __field,
1685 _serde::__private::None => {
1686 #[cfg(feature = "strict")]
1687 return _serde::__private::Err(
1688 <__A::Error as _serde::de::Error>::missing_field(
1689 "worldFromModel",
1690 ),
1691 );
1692 #[cfg(not(feature = "strict"))] Default::default()
1693 }
1694 };
1695 let m_poseModelSpace = match m_poseModelSpace {
1696 _serde::__private::Some(__field) => __field,
1697 _serde::__private::None => {
1698 #[cfg(feature = "strict")]
1699 return _serde::__private::Err(
1700 <__A::Error as _serde::de::Error>::missing_field(
1701 "poseModelSpace",
1702 ),
1703 );
1704 #[cfg(not(feature = "strict"))] Default::default()
1705 }
1706 };
1707 let m_rigidAttachmentTransforms = match m_rigidAttachmentTransforms {
1708 _serde::__private::Some(__field) => __field,
1709 _serde::__private::None => {
1710 #[cfg(feature = "strict")]
1711 return _serde::__private::Err(
1712 <__A::Error as _serde::de::Error>::missing_field(
1713 "rigidAttachmentTransforms",
1714 ),
1715 );
1716 #[cfg(not(feature = "strict"))] Default::default()
1717 }
1718 };
1719 let __ptr = None;
1720 let parent = hkBaseObject { __ptr };
1721 let parent = hkReferencedObject {
1722 __ptr,
1723 parent,
1724 ..Default::default()
1725 };
1726 let __ptr = __A::class_ptr(&mut __map);
1727 _serde::__private::Ok(hkbClientCharacterState {
1728 __ptr,
1729 parent,
1730 m_deformableSkinIds,
1731 m_rigidSkinIds,
1732 m_externalEventIds,
1733 m_auxiliaryInfo,
1734 m_activeEventIds,
1735 m_activeVariableIds,
1736 m_characterId,
1737 m_instanceName,
1738 m_templateName,
1739 m_fullPathToProject,
1740 m_behaviorData,
1741 m_behaviorInternalState,
1742 m_visible,
1743 m_elapsedSimulationTime,
1744 m_skeleton,
1745 m_worldFromModel,
1746 m_poseModelSpace,
1747 m_rigidAttachmentTransforms,
1748 ..Default::default()
1749 })
1750 }
1751 }
1752 const FIELDS: &[&str] = &[
1753 "deformableSkinIds",
1754 "rigidSkinIds",
1755 "externalEventIds",
1756 "auxiliaryInfo",
1757 "activeEventIds",
1758 "activeVariableIds",
1759 "characterId",
1760 "instanceName",
1761 "templateName",
1762 "fullPathToProject",
1763 "behaviorData",
1764 "behaviorInternalState",
1765 "nodeIdToInternalStateMap",
1766 "visible",
1767 "elapsedSimulationTime",
1768 "skeleton",
1769 "worldFromModel",
1770 "poseModelSpace",
1771 "rigidAttachmentTransforms",
1772 ];
1773 _serde::Deserializer::deserialize_struct(
1774 deserializer,
1775 "hkbClientCharacterState",
1776 FIELDS,
1777 __hkbClientCharacterStateVisitor {
1778 marker: _serde::__private::PhantomData::<hkbClientCharacterState>,
1779 lifetime: _serde::__private::PhantomData,
1780 },
1781 )
1782 }
1783 }
1784};