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 hkbCharacterAddedInfo<'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 = "characterId"))]
35 #[cfg_attr(feature = "serde", serde(rename = "characterId"))]
36 pub m_characterId: u64,
37 #[cfg_attr(feature = "serde", serde(borrow))]
42 #[cfg_attr(feature = "json_schema", schemars(rename = "instanceName"))]
43 #[cfg_attr(feature = "serde", serde(rename = "instanceName"))]
44 pub m_instanceName: StringPtr<'a>,
45 #[cfg_attr(feature = "serde", serde(borrow))]
50 #[cfg_attr(feature = "json_schema", schemars(rename = "templateName"))]
51 #[cfg_attr(feature = "serde", serde(rename = "templateName"))]
52 pub m_templateName: StringPtr<'a>,
53 #[cfg_attr(feature = "serde", serde(borrow))]
58 #[cfg_attr(feature = "json_schema", schemars(rename = "fullPathToProject"))]
59 #[cfg_attr(feature = "serde", serde(rename = "fullPathToProject"))]
60 pub m_fullPathToProject: StringPtr<'a>,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "skeleton"))]
66 #[cfg_attr(feature = "serde", serde(rename = "skeleton"))]
67 pub m_skeleton: Pointer,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "worldFromModel"))]
73 #[cfg_attr(feature = "serde", serde(rename = "worldFromModel"))]
74 pub m_worldFromModel: QsTransform,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "poseModelSpace"))]
80 #[cfg_attr(feature = "serde", serde(rename = "poseModelSpace"))]
81 pub m_poseModelSpace: Vec<QsTransform>,
82}
83const _: () = {
84 use havok_serde as _serde;
85 impl<'a> _serde::HavokClass for hkbCharacterAddedInfo<'a> {
86 #[inline]
87 fn name(&self) -> &'static str {
88 "hkbCharacterAddedInfo"
89 }
90 #[inline]
91 fn signature(&self) -> _serde::__private::Signature {
92 _serde::__private::Signature::new(0x3544e182)
93 }
94 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
95 fn deps_indexes(&self) -> Vec<usize> {
96 let mut v = Vec::new();
97 v.push(self.m_skeleton.get());
98 v
99 }
100 }
101 impl<'a> _serde::Serialize for hkbCharacterAddedInfo<'a> {
102 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
103 where
104 S: _serde::ser::Serializer,
105 {
106 let class_meta = self
107 .__ptr
108 .map(|name| (name, _serde::__private::Signature::new(0x3544e182)));
109 let mut serializer = __serializer
110 .serialize_struct("hkbCharacterAddedInfo", class_meta, (96u64, 128u64))?;
111 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
112 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
113 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
114 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
115 serializer.serialize_field("characterId", &self.m_characterId)?;
116 serializer.serialize_field("instanceName", &self.m_instanceName)?;
117 serializer.serialize_field("templateName", &self.m_templateName)?;
118 serializer.serialize_field("fullPathToProject", &self.m_fullPathToProject)?;
119 serializer.serialize_field("skeleton", &self.m_skeleton)?;
120 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 8usize].as_slice())?;
121 serializer.serialize_field("worldFromModel", &self.m_worldFromModel)?;
122 serializer
123 .serialize_array_field(
124 "poseModelSpace",
125 &self.m_poseModelSpace,
126 TypeSize::NonPtr,
127 )?;
128 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
129 serializer.end()
130 }
131 }
132};
133#[doc(hidden)]
134#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
135const _: () = {
136 use havok_serde as _serde;
137 #[automatically_derived]
138 impl<'de> _serde::Deserialize<'de> for hkbCharacterAddedInfo<'de> {
139 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
140 where
141 __D: _serde::Deserializer<'de>,
142 {
143 #[allow(non_camel_case_types)]
144 enum __Field {
145 m_characterId,
146 m_instanceName,
147 m_templateName,
148 m_fullPathToProject,
149 m_skeleton,
150 m_worldFromModel,
151 m_poseModelSpace,
152 __ignore,
153 }
154 struct __FieldVisitor;
155 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
156 type Value = __Field;
157 fn expecting(
158 &self,
159 __formatter: &mut core::fmt::Formatter,
160 ) -> core::fmt::Result {
161 core::fmt::Formatter::write_str(__formatter, "field identifier")
162 }
163 #[allow(clippy::match_single_binding)]
165 #[allow(clippy::reversed_empty_ranges)]
166 #[allow(clippy::single_match)]
167 fn visit_key<__E>(
168 self,
169 __value: &str,
170 ) -> core::result::Result<Self::Value, __E>
171 where
172 __E: _serde::de::Error,
173 {
174 match __value {
175 "characterId" => Ok(__Field::m_characterId),
176 "instanceName" => Ok(__Field::m_instanceName),
177 "templateName" => Ok(__Field::m_templateName),
178 "fullPathToProject" => Ok(__Field::m_fullPathToProject),
179 "skeleton" => Ok(__Field::m_skeleton),
180 "worldFromModel" => Ok(__Field::m_worldFromModel),
181 "poseModelSpace" => Ok(__Field::m_poseModelSpace),
182 _ => Ok(__Field::__ignore),
183 }
184 }
185 }
186 impl<'de> _serde::Deserialize<'de> for __Field {
187 #[inline]
188 fn deserialize<__D>(
189 __deserializer: __D,
190 ) -> core::result::Result<Self, __D::Error>
191 where
192 __D: _serde::Deserializer<'de>,
193 {
194 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
195 }
196 }
197 struct __hkbCharacterAddedInfoVisitor<'de> {
198 marker: _serde::__private::PhantomData<hkbCharacterAddedInfo<'de>>,
199 lifetime: _serde::__private::PhantomData<&'de ()>,
200 }
201 #[allow(clippy::match_single_binding)]
202 #[allow(clippy::reversed_empty_ranges)]
203 #[allow(clippy::single_match)]
204 impl<'de> _serde::de::Visitor<'de> for __hkbCharacterAddedInfoVisitor<'de> {
205 type Value = hkbCharacterAddedInfo<'de>;
206 fn expecting(
207 &self,
208 __formatter: &mut core::fmt::Formatter,
209 ) -> core::fmt::Result {
210 core::fmt::Formatter::write_str(
211 __formatter,
212 "struct hkbCharacterAddedInfo",
213 )
214 }
215 fn visit_struct_for_bytes<__A>(
216 self,
217 mut __map: __A,
218 ) -> _serde::__private::Result<Self::Value, __A::Error>
219 where
220 __A: _serde::de::MapAccess<'de>,
221 {
222 let __ptr = __A::class_ptr(&mut __map);
223 let parent = __A::parent_value(&mut __map)?;
224 let mut m_characterId: _serde::__private::Option<u64> = _serde::__private::None;
225 let mut m_instanceName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
226 let mut m_templateName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
227 let mut m_fullPathToProject: _serde::__private::Option<
228 StringPtr<'de>,
229 > = _serde::__private::None;
230 let mut m_skeleton: _serde::__private::Option<Pointer> = _serde::__private::None;
231 let mut m_worldFromModel: _serde::__private::Option<QsTransform> = _serde::__private::None;
232 let mut m_poseModelSpace: _serde::__private::Option<
233 Vec<QsTransform>,
234 > = _serde::__private::None;
235 for i in 0..7usize {
236 match i {
237 0usize => {
238 if _serde::__private::Option::is_some(&m_characterId) {
239 return _serde::__private::Err(
240 <__A::Error as _serde::de::Error>::duplicate_field(
241 "characterId",
242 ),
243 );
244 }
245 m_characterId = _serde::__private::Some(
246 match __A::next_value::<u64>(&mut __map) {
247 _serde::__private::Ok(__val) => __val,
248 _serde::__private::Err(__err) => {
249 return _serde::__private::Err(__err);
250 }
251 },
252 );
253 }
254 1usize => {
255 if _serde::__private::Option::is_some(&m_instanceName) {
256 return _serde::__private::Err(
257 <__A::Error as _serde::de::Error>::duplicate_field(
258 "instanceName",
259 ),
260 );
261 }
262 m_instanceName = _serde::__private::Some(
263 match __A::next_value::<StringPtr<'de>>(&mut __map) {
264 _serde::__private::Ok(__val) => __val,
265 _serde::__private::Err(__err) => {
266 return _serde::__private::Err(__err);
267 }
268 },
269 );
270 }
271 2usize => {
272 if _serde::__private::Option::is_some(&m_templateName) {
273 return _serde::__private::Err(
274 <__A::Error as _serde::de::Error>::duplicate_field(
275 "templateName",
276 ),
277 );
278 }
279 m_templateName = _serde::__private::Some(
280 match __A::next_value::<StringPtr<'de>>(&mut __map) {
281 _serde::__private::Ok(__val) => __val,
282 _serde::__private::Err(__err) => {
283 return _serde::__private::Err(__err);
284 }
285 },
286 );
287 }
288 3usize => {
289 if _serde::__private::Option::is_some(
290 &m_fullPathToProject,
291 ) {
292 return _serde::__private::Err(
293 <__A::Error as _serde::de::Error>::duplicate_field(
294 "fullPathToProject",
295 ),
296 );
297 }
298 m_fullPathToProject = _serde::__private::Some(
299 match __A::next_value::<StringPtr<'de>>(&mut __map) {
300 _serde::__private::Ok(__val) => __val,
301 _serde::__private::Err(__err) => {
302 return _serde::__private::Err(__err);
303 }
304 },
305 );
306 }
307 4usize => {
308 if _serde::__private::Option::is_some(&m_skeleton) {
309 return _serde::__private::Err(
310 <__A::Error as _serde::de::Error>::duplicate_field(
311 "skeleton",
312 ),
313 );
314 }
315 m_skeleton = _serde::__private::Some(
316 match __A::next_value::<Pointer>(&mut __map) {
317 _serde::__private::Ok(__val) => __val,
318 _serde::__private::Err(__err) => {
319 return _serde::__private::Err(__err);
320 }
321 },
322 );
323 }
324 5usize => {
325 if _serde::__private::Option::is_some(&m_worldFromModel) {
326 return _serde::__private::Err(
327 <__A::Error as _serde::de::Error>::duplicate_field(
328 "worldFromModel",
329 ),
330 );
331 }
332 __A::pad(&mut __map, 0usize, 8usize)?;
333 m_worldFromModel = _serde::__private::Some(
334 match __A::next_value::<QsTransform>(&mut __map) {
335 _serde::__private::Ok(__val) => __val,
336 _serde::__private::Err(__err) => {
337 return _serde::__private::Err(__err);
338 }
339 },
340 );
341 }
342 6usize => {
343 if _serde::__private::Option::is_some(&m_poseModelSpace) {
344 return _serde::__private::Err(
345 <__A::Error as _serde::de::Error>::duplicate_field(
346 "poseModelSpace",
347 ),
348 );
349 }
350 m_poseModelSpace = _serde::__private::Some(
351 match __A::next_value::<Vec<QsTransform>>(&mut __map) {
352 _serde::__private::Ok(__val) => __val,
353 _serde::__private::Err(__err) => {
354 return _serde::__private::Err(__err);
355 }
356 },
357 );
358 }
359 _ => {}
360 }
361 }
362 __A::pad(&mut __map, 4usize, 0usize)?;
363 let m_characterId = match m_characterId {
364 _serde::__private::Some(__field) => __field,
365 _serde::__private::None => {
366 return _serde::__private::Err(
367 <__A::Error as _serde::de::Error>::missing_field(
368 "characterId",
369 ),
370 );
371 }
372 };
373 let m_instanceName = match m_instanceName {
374 _serde::__private::Some(__field) => __field,
375 _serde::__private::None => {
376 return _serde::__private::Err(
377 <__A::Error as _serde::de::Error>::missing_field(
378 "instanceName",
379 ),
380 );
381 }
382 };
383 let m_templateName = match m_templateName {
384 _serde::__private::Some(__field) => __field,
385 _serde::__private::None => {
386 return _serde::__private::Err(
387 <__A::Error as _serde::de::Error>::missing_field(
388 "templateName",
389 ),
390 );
391 }
392 };
393 let m_fullPathToProject = match m_fullPathToProject {
394 _serde::__private::Some(__field) => __field,
395 _serde::__private::None => {
396 return _serde::__private::Err(
397 <__A::Error as _serde::de::Error>::missing_field(
398 "fullPathToProject",
399 ),
400 );
401 }
402 };
403 let m_skeleton = match m_skeleton {
404 _serde::__private::Some(__field) => __field,
405 _serde::__private::None => {
406 return _serde::__private::Err(
407 <__A::Error as _serde::de::Error>::missing_field("skeleton"),
408 );
409 }
410 };
411 let m_worldFromModel = match m_worldFromModel {
412 _serde::__private::Some(__field) => __field,
413 _serde::__private::None => {
414 return _serde::__private::Err(
415 <__A::Error as _serde::de::Error>::missing_field(
416 "worldFromModel",
417 ),
418 );
419 }
420 };
421 let m_poseModelSpace = match m_poseModelSpace {
422 _serde::__private::Some(__field) => __field,
423 _serde::__private::None => {
424 return _serde::__private::Err(
425 <__A::Error as _serde::de::Error>::missing_field(
426 "poseModelSpace",
427 ),
428 );
429 }
430 };
431 _serde::__private::Ok(hkbCharacterAddedInfo {
432 __ptr,
433 parent,
434 m_characterId,
435 m_instanceName,
436 m_templateName,
437 m_fullPathToProject,
438 m_skeleton,
439 m_worldFromModel,
440 m_poseModelSpace,
441 })
442 }
443 #[allow(clippy::manual_unwrap_or_default)]
444 fn visit_struct<__A>(
445 self,
446 mut __map: __A,
447 ) -> _serde::__private::Result<Self::Value, __A::Error>
448 where
449 __A: _serde::de::MapAccess<'de>,
450 {
451 let mut m_characterId: _serde::__private::Option<u64> = _serde::__private::None;
452 let mut m_instanceName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
453 let mut m_templateName: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
454 let mut m_fullPathToProject: _serde::__private::Option<
455 StringPtr<'de>,
456 > = _serde::__private::None;
457 let mut m_skeleton: _serde::__private::Option<Pointer> = _serde::__private::None;
458 let mut m_worldFromModel: _serde::__private::Option<QsTransform> = _serde::__private::None;
459 let mut m_poseModelSpace: _serde::__private::Option<
460 Vec<QsTransform>,
461 > = _serde::__private::None;
462 while let _serde::__private::Some(__key) = {
463 __A::next_key::<__Field>(&mut __map)?
464 } {
465 match __key {
466 __Field::m_characterId => {
467 #[cfg(
468 any(feature = "strict", feature = "ignore_duplicates")
469 )]
470 if _serde::__private::Option::is_some(&m_characterId) {
471 #[cfg(feature = "ignore_duplicates")]
472 {
473 __A::skip_value(&mut __map)?;
474 continue;
475 }
476 #[cfg(feature = "strict")]
477 return _serde::__private::Err(
478 <__A::Error as _serde::de::Error>::duplicate_field(
479 "characterId",
480 ),
481 );
482 }
483 m_characterId = _serde::__private::Some(
484 match __A::next_value::<u64>(&mut __map) {
485 _serde::__private::Ok(__val) => __val,
486 _serde::__private::Err(__err) => {
487 return _serde::__private::Err(__err);
488 }
489 },
490 );
491 }
492 __Field::m_instanceName => {
493 #[cfg(
494 any(feature = "strict", feature = "ignore_duplicates")
495 )]
496 if _serde::__private::Option::is_some(&m_instanceName) {
497 #[cfg(feature = "ignore_duplicates")]
498 {
499 __A::skip_value(&mut __map)?;
500 continue;
501 }
502 #[cfg(feature = "strict")]
503 return _serde::__private::Err(
504 <__A::Error as _serde::de::Error>::duplicate_field(
505 "instanceName",
506 ),
507 );
508 }
509 m_instanceName = _serde::__private::Some(
510 match __A::next_value::<StringPtr<'de>>(&mut __map) {
511 _serde::__private::Ok(__val) => __val,
512 _serde::__private::Err(__err) => {
513 return _serde::__private::Err(__err);
514 }
515 },
516 );
517 }
518 __Field::m_templateName => {
519 #[cfg(
520 any(feature = "strict", feature = "ignore_duplicates")
521 )]
522 if _serde::__private::Option::is_some(&m_templateName) {
523 #[cfg(feature = "ignore_duplicates")]
524 {
525 __A::skip_value(&mut __map)?;
526 continue;
527 }
528 #[cfg(feature = "strict")]
529 return _serde::__private::Err(
530 <__A::Error as _serde::de::Error>::duplicate_field(
531 "templateName",
532 ),
533 );
534 }
535 m_templateName = _serde::__private::Some(
536 match __A::next_value::<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 __Field::m_fullPathToProject => {
545 #[cfg(
546 any(feature = "strict", feature = "ignore_duplicates")
547 )]
548 if _serde::__private::Option::is_some(
549 &m_fullPathToProject,
550 ) {
551 #[cfg(feature = "ignore_duplicates")]
552 {
553 __A::skip_value(&mut __map)?;
554 continue;
555 }
556 #[cfg(feature = "strict")]
557 return _serde::__private::Err(
558 <__A::Error as _serde::de::Error>::duplicate_field(
559 "fullPathToProject",
560 ),
561 );
562 }
563 m_fullPathToProject = _serde::__private::Some(
564 match __A::next_value::<StringPtr<'de>>(&mut __map) {
565 _serde::__private::Ok(__val) => __val,
566 _serde::__private::Err(__err) => {
567 return _serde::__private::Err(__err);
568 }
569 },
570 );
571 }
572 __Field::m_skeleton => {
573 #[cfg(
574 any(feature = "strict", feature = "ignore_duplicates")
575 )]
576 if _serde::__private::Option::is_some(&m_skeleton) {
577 #[cfg(feature = "ignore_duplicates")]
578 {
579 __A::skip_value(&mut __map)?;
580 continue;
581 }
582 #[cfg(feature = "strict")]
583 return _serde::__private::Err(
584 <__A::Error as _serde::de::Error>::duplicate_field(
585 "skeleton",
586 ),
587 );
588 }
589 m_skeleton = _serde::__private::Some(
590 match __A::next_value::<Pointer>(&mut __map) {
591 _serde::__private::Ok(__val) => __val,
592 _serde::__private::Err(__err) => {
593 return _serde::__private::Err(__err);
594 }
595 },
596 );
597 }
598 __Field::m_worldFromModel => {
599 #[cfg(
600 any(feature = "strict", feature = "ignore_duplicates")
601 )]
602 if _serde::__private::Option::is_some(&m_worldFromModel) {
603 #[cfg(feature = "ignore_duplicates")]
604 {
605 __A::skip_value(&mut __map)?;
606 continue;
607 }
608 #[cfg(feature = "strict")]
609 return _serde::__private::Err(
610 <__A::Error as _serde::de::Error>::duplicate_field(
611 "worldFromModel",
612 ),
613 );
614 }
615 m_worldFromModel = _serde::__private::Some(
616 match __A::next_value::<QsTransform>(&mut __map) {
617 _serde::__private::Ok(__val) => __val,
618 _serde::__private::Err(__err) => {
619 return _serde::__private::Err(__err);
620 }
621 },
622 );
623 }
624 __Field::m_poseModelSpace => {
625 #[cfg(
626 any(feature = "strict", feature = "ignore_duplicates")
627 )]
628 if _serde::__private::Option::is_some(&m_poseModelSpace) {
629 #[cfg(feature = "ignore_duplicates")]
630 {
631 __A::skip_value(&mut __map)?;
632 continue;
633 }
634 #[cfg(feature = "strict")]
635 return _serde::__private::Err(
636 <__A::Error as _serde::de::Error>::duplicate_field(
637 "poseModelSpace",
638 ),
639 );
640 }
641 m_poseModelSpace = _serde::__private::Some(
642 match __A::next_value::<Vec<QsTransform>>(&mut __map) {
643 _serde::__private::Ok(__val) => __val,
644 _serde::__private::Err(__err) => {
645 return _serde::__private::Err(__err);
646 }
647 },
648 );
649 }
650 _ => __A::skip_value(&mut __map)?,
651 }
652 }
653 let m_characterId = match m_characterId {
654 _serde::__private::Some(__field) => __field,
655 _serde::__private::None => {
656 #[cfg(feature = "strict")]
657 return _serde::__private::Err(
658 <__A::Error as _serde::de::Error>::missing_field(
659 "characterId",
660 ),
661 );
662 #[cfg(not(feature = "strict"))] Default::default()
663 }
664 };
665 let m_instanceName = match m_instanceName {
666 _serde::__private::Some(__field) => __field,
667 _serde::__private::None => {
668 #[cfg(feature = "strict")]
669 return _serde::__private::Err(
670 <__A::Error as _serde::de::Error>::missing_field(
671 "instanceName",
672 ),
673 );
674 #[cfg(not(feature = "strict"))] Default::default()
675 }
676 };
677 let m_templateName = match m_templateName {
678 _serde::__private::Some(__field) => __field,
679 _serde::__private::None => {
680 #[cfg(feature = "strict")]
681 return _serde::__private::Err(
682 <__A::Error as _serde::de::Error>::missing_field(
683 "templateName",
684 ),
685 );
686 #[cfg(not(feature = "strict"))] Default::default()
687 }
688 };
689 let m_fullPathToProject = match m_fullPathToProject {
690 _serde::__private::Some(__field) => __field,
691 _serde::__private::None => {
692 #[cfg(feature = "strict")]
693 return _serde::__private::Err(
694 <__A::Error as _serde::de::Error>::missing_field(
695 "fullPathToProject",
696 ),
697 );
698 #[cfg(not(feature = "strict"))] Default::default()
699 }
700 };
701 let m_skeleton = match m_skeleton {
702 _serde::__private::Some(__field) => __field,
703 _serde::__private::None => {
704 #[cfg(feature = "strict")]
705 return _serde::__private::Err(
706 <__A::Error as _serde::de::Error>::missing_field("skeleton"),
707 );
708 #[cfg(not(feature = "strict"))] Default::default()
709 }
710 };
711 let m_worldFromModel = match m_worldFromModel {
712 _serde::__private::Some(__field) => __field,
713 _serde::__private::None => {
714 #[cfg(feature = "strict")]
715 return _serde::__private::Err(
716 <__A::Error as _serde::de::Error>::missing_field(
717 "worldFromModel",
718 ),
719 );
720 #[cfg(not(feature = "strict"))] Default::default()
721 }
722 };
723 let m_poseModelSpace = match m_poseModelSpace {
724 _serde::__private::Some(__field) => __field,
725 _serde::__private::None => {
726 #[cfg(feature = "strict")]
727 return _serde::__private::Err(
728 <__A::Error as _serde::de::Error>::missing_field(
729 "poseModelSpace",
730 ),
731 );
732 #[cfg(not(feature = "strict"))] Default::default()
733 }
734 };
735 let __ptr = None;
736 let parent = hkBaseObject { __ptr };
737 let parent = hkReferencedObject {
738 __ptr,
739 parent,
740 ..Default::default()
741 };
742 let __ptr = __A::class_ptr(&mut __map);
743 _serde::__private::Ok(hkbCharacterAddedInfo {
744 __ptr,
745 parent,
746 m_characterId,
747 m_instanceName,
748 m_templateName,
749 m_fullPathToProject,
750 m_skeleton,
751 m_worldFromModel,
752 m_poseModelSpace,
753 })
754 }
755 }
756 const FIELDS: &[&str] = &[
757 "characterId",
758 "instanceName",
759 "templateName",
760 "fullPathToProject",
761 "skeleton",
762 "worldFromModel",
763 "poseModelSpace",
764 ];
765 _serde::Deserializer::deserialize_struct(
766 deserializer,
767 "hkbCharacterAddedInfo",
768 FIELDS,
769 __hkbCharacterAddedInfoVisitor {
770 marker: _serde::__private::PhantomData::<hkbCharacterAddedInfo>,
771 lifetime: _serde::__private::PhantomData,
772 },
773 )
774 }
775 }
776};