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