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 hkaAnimationContainer {
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 = "skeletons"))]
35 #[cfg_attr(feature = "serde", serde(rename = "skeletons"))]
36 pub m_skeletons: Vec<Pointer>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "animations"))]
42 #[cfg_attr(feature = "serde", serde(rename = "animations"))]
43 pub m_animations: Vec<Pointer>,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "bindings"))]
49 #[cfg_attr(feature = "serde", serde(rename = "bindings"))]
50 pub m_bindings: Vec<Pointer>,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "attachments"))]
56 #[cfg_attr(feature = "serde", serde(rename = "attachments"))]
57 pub m_attachments: Vec<Pointer>,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "skins"))]
63 #[cfg_attr(feature = "serde", serde(rename = "skins"))]
64 pub m_skins: Vec<Pointer>,
65}
66const _: () = {
67 use havok_serde as _serde;
68 impl _serde::HavokClass for hkaAnimationContainer {
69 #[inline]
70 fn name(&self) -> &'static str {
71 "hkaAnimationContainer"
72 }
73 #[inline]
74 fn signature(&self) -> _serde::__private::Signature {
75 _serde::__private::Signature::new(0x8dc20333)
76 }
77 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
78 fn deps_indexes(&self) -> Vec<usize> {
79 let mut v = Vec::new();
80 v.extend(self.m_skeletons.iter().map(|ptr| ptr.get()));
81 v.extend(self.m_animations.iter().map(|ptr| ptr.get()));
82 v.extend(self.m_bindings.iter().map(|ptr| ptr.get()));
83 v.extend(self.m_attachments.iter().map(|ptr| ptr.get()));
84 v.extend(self.m_skins.iter().map(|ptr| ptr.get()));
85 v
86 }
87 }
88 impl _serde::Serialize for hkaAnimationContainer {
89 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
90 where
91 S: _serde::ser::Serializer,
92 {
93 let class_meta = self
94 .__ptr
95 .map(|name| (name, _serde::__private::Signature::new(0x8dc20333)));
96 let mut serializer = __serializer
97 .serialize_struct("hkaAnimationContainer", class_meta, (68u64, 96u64))?;
98 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
99 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
100 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
101 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
102 serializer
103 .serialize_array_field(
104 "skeletons",
105 &self.m_skeletons,
106 TypeSize::NonPtr,
107 )?;
108 serializer
109 .serialize_array_field(
110 "animations",
111 &self.m_animations,
112 TypeSize::NonPtr,
113 )?;
114 serializer
115 .serialize_array_field("bindings", &self.m_bindings, TypeSize::NonPtr)?;
116 serializer
117 .serialize_array_field(
118 "attachments",
119 &self.m_attachments,
120 TypeSize::NonPtr,
121 )?;
122 serializer.serialize_array_field("skins", &self.m_skins, TypeSize::NonPtr)?;
123 serializer.end()
124 }
125 }
126};
127#[doc(hidden)]
128#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
129const _: () = {
130 use havok_serde as _serde;
131 #[automatically_derived]
132 impl<'de> _serde::Deserialize<'de> for hkaAnimationContainer {
133 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
134 where
135 __D: _serde::Deserializer<'de>,
136 {
137 #[allow(non_camel_case_types)]
138 enum __Field {
139 m_skeletons,
140 m_animations,
141 m_bindings,
142 m_attachments,
143 m_skins,
144 __ignore,
145 }
146 struct __FieldVisitor;
147 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
148 type Value = __Field;
149 fn expecting(
150 &self,
151 __formatter: &mut core::fmt::Formatter,
152 ) -> core::fmt::Result {
153 core::fmt::Formatter::write_str(__formatter, "field identifier")
154 }
155 #[allow(clippy::match_single_binding)]
157 #[allow(clippy::reversed_empty_ranges)]
158 #[allow(clippy::single_match)]
159 fn visit_key<__E>(
160 self,
161 __value: &str,
162 ) -> core::result::Result<Self::Value, __E>
163 where
164 __E: _serde::de::Error,
165 {
166 match __value {
167 "skeletons" => Ok(__Field::m_skeletons),
168 "animations" => Ok(__Field::m_animations),
169 "bindings" => Ok(__Field::m_bindings),
170 "attachments" => Ok(__Field::m_attachments),
171 "skins" => Ok(__Field::m_skins),
172 _ => Ok(__Field::__ignore),
173 }
174 }
175 }
176 impl<'de> _serde::Deserialize<'de> for __Field {
177 #[inline]
178 fn deserialize<__D>(
179 __deserializer: __D,
180 ) -> core::result::Result<Self, __D::Error>
181 where
182 __D: _serde::Deserializer<'de>,
183 {
184 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
185 }
186 }
187 struct __hkaAnimationContainerVisitor<'de> {
188 marker: _serde::__private::PhantomData<hkaAnimationContainer>,
189 lifetime: _serde::__private::PhantomData<&'de ()>,
190 }
191 #[allow(clippy::match_single_binding)]
192 #[allow(clippy::reversed_empty_ranges)]
193 #[allow(clippy::single_match)]
194 impl<'de> _serde::de::Visitor<'de> for __hkaAnimationContainerVisitor<'de> {
195 type Value = hkaAnimationContainer;
196 fn expecting(
197 &self,
198 __formatter: &mut core::fmt::Formatter,
199 ) -> core::fmt::Result {
200 core::fmt::Formatter::write_str(
201 __formatter,
202 "struct hkaAnimationContainer",
203 )
204 }
205 fn visit_struct_for_bytes<__A>(
206 self,
207 mut __map: __A,
208 ) -> _serde::__private::Result<Self::Value, __A::Error>
209 where
210 __A: _serde::de::MapAccess<'de>,
211 {
212 let __ptr = __A::class_ptr(&mut __map);
213 let parent = __A::parent_value(&mut __map)?;
214 let mut m_skeletons: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
215 let mut m_animations: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
216 let mut m_bindings: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
217 let mut m_attachments: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
218 let mut m_skins: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
219 for i in 0..5usize {
220 match i {
221 0usize => {
222 if _serde::__private::Option::is_some(&m_skeletons) {
223 return _serde::__private::Err(
224 <__A::Error as _serde::de::Error>::duplicate_field(
225 "skeletons",
226 ),
227 );
228 }
229 m_skeletons = _serde::__private::Some(
230 match __A::next_value::<Vec<Pointer>>(&mut __map) {
231 _serde::__private::Ok(__val) => __val,
232 _serde::__private::Err(__err) => {
233 return _serde::__private::Err(__err);
234 }
235 },
236 );
237 }
238 1usize => {
239 if _serde::__private::Option::is_some(&m_animations) {
240 return _serde::__private::Err(
241 <__A::Error as _serde::de::Error>::duplicate_field(
242 "animations",
243 ),
244 );
245 }
246 m_animations = _serde::__private::Some(
247 match __A::next_value::<Vec<Pointer>>(&mut __map) {
248 _serde::__private::Ok(__val) => __val,
249 _serde::__private::Err(__err) => {
250 return _serde::__private::Err(__err);
251 }
252 },
253 );
254 }
255 2usize => {
256 if _serde::__private::Option::is_some(&m_bindings) {
257 return _serde::__private::Err(
258 <__A::Error as _serde::de::Error>::duplicate_field(
259 "bindings",
260 ),
261 );
262 }
263 m_bindings = _serde::__private::Some(
264 match __A::next_value::<Vec<Pointer>>(&mut __map) {
265 _serde::__private::Ok(__val) => __val,
266 _serde::__private::Err(__err) => {
267 return _serde::__private::Err(__err);
268 }
269 },
270 );
271 }
272 3usize => {
273 if _serde::__private::Option::is_some(&m_attachments) {
274 return _serde::__private::Err(
275 <__A::Error as _serde::de::Error>::duplicate_field(
276 "attachments",
277 ),
278 );
279 }
280 m_attachments = _serde::__private::Some(
281 match __A::next_value::<Vec<Pointer>>(&mut __map) {
282 _serde::__private::Ok(__val) => __val,
283 _serde::__private::Err(__err) => {
284 return _serde::__private::Err(__err);
285 }
286 },
287 );
288 }
289 4usize => {
290 if _serde::__private::Option::is_some(&m_skins) {
291 return _serde::__private::Err(
292 <__A::Error as _serde::de::Error>::duplicate_field("skins"),
293 );
294 }
295 m_skins = _serde::__private::Some(
296 match __A::next_value::<Vec<Pointer>>(&mut __map) {
297 _serde::__private::Ok(__val) => __val,
298 _serde::__private::Err(__err) => {
299 return _serde::__private::Err(__err);
300 }
301 },
302 );
303 }
304 _ => {}
305 }
306 }
307 let m_skeletons = match m_skeletons {
308 _serde::__private::Some(__field) => __field,
309 _serde::__private::None => {
310 return _serde::__private::Err(
311 <__A::Error as _serde::de::Error>::missing_field(
312 "skeletons",
313 ),
314 );
315 }
316 };
317 let m_animations = match m_animations {
318 _serde::__private::Some(__field) => __field,
319 _serde::__private::None => {
320 return _serde::__private::Err(
321 <__A::Error as _serde::de::Error>::missing_field(
322 "animations",
323 ),
324 );
325 }
326 };
327 let m_bindings = match m_bindings {
328 _serde::__private::Some(__field) => __field,
329 _serde::__private::None => {
330 return _serde::__private::Err(
331 <__A::Error as _serde::de::Error>::missing_field("bindings"),
332 );
333 }
334 };
335 let m_attachments = match m_attachments {
336 _serde::__private::Some(__field) => __field,
337 _serde::__private::None => {
338 return _serde::__private::Err(
339 <__A::Error as _serde::de::Error>::missing_field(
340 "attachments",
341 ),
342 );
343 }
344 };
345 let m_skins = match m_skins {
346 _serde::__private::Some(__field) => __field,
347 _serde::__private::None => {
348 return _serde::__private::Err(
349 <__A::Error as _serde::de::Error>::missing_field("skins"),
350 );
351 }
352 };
353 _serde::__private::Ok(hkaAnimationContainer {
354 __ptr,
355 parent,
356 m_skeletons,
357 m_animations,
358 m_bindings,
359 m_attachments,
360 m_skins,
361 })
362 }
363 #[allow(clippy::manual_unwrap_or_default)]
364 fn visit_struct<__A>(
365 self,
366 mut __map: __A,
367 ) -> _serde::__private::Result<Self::Value, __A::Error>
368 where
369 __A: _serde::de::MapAccess<'de>,
370 {
371 let mut m_skeletons: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
372 let mut m_animations: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
373 let mut m_bindings: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
374 let mut m_attachments: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
375 let mut m_skins: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
376 while let _serde::__private::Some(__key) = {
377 __A::next_key::<__Field>(&mut __map)?
378 } {
379 match __key {
380 __Field::m_skeletons => {
381 #[cfg(
382 any(feature = "strict", feature = "ignore_duplicates")
383 )]
384 if _serde::__private::Option::is_some(&m_skeletons) {
385 #[cfg(feature = "ignore_duplicates")]
386 {
387 __A::skip_value(&mut __map)?;
388 continue;
389 }
390 #[cfg(feature = "strict")]
391 return _serde::__private::Err(
392 <__A::Error as _serde::de::Error>::duplicate_field(
393 "skeletons",
394 ),
395 );
396 }
397 m_skeletons = _serde::__private::Some(
398 match __A::next_value::<Vec<Pointer>>(&mut __map) {
399 _serde::__private::Ok(__val) => __val,
400 _serde::__private::Err(__err) => {
401 return _serde::__private::Err(__err);
402 }
403 },
404 );
405 }
406 __Field::m_animations => {
407 #[cfg(
408 any(feature = "strict", feature = "ignore_duplicates")
409 )]
410 if _serde::__private::Option::is_some(&m_animations) {
411 #[cfg(feature = "ignore_duplicates")]
412 {
413 __A::skip_value(&mut __map)?;
414 continue;
415 }
416 #[cfg(feature = "strict")]
417 return _serde::__private::Err(
418 <__A::Error as _serde::de::Error>::duplicate_field(
419 "animations",
420 ),
421 );
422 }
423 m_animations = _serde::__private::Some(
424 match __A::next_value::<Vec<Pointer>>(&mut __map) {
425 _serde::__private::Ok(__val) => __val,
426 _serde::__private::Err(__err) => {
427 return _serde::__private::Err(__err);
428 }
429 },
430 );
431 }
432 __Field::m_bindings => {
433 #[cfg(
434 any(feature = "strict", feature = "ignore_duplicates")
435 )]
436 if _serde::__private::Option::is_some(&m_bindings) {
437 #[cfg(feature = "ignore_duplicates")]
438 {
439 __A::skip_value(&mut __map)?;
440 continue;
441 }
442 #[cfg(feature = "strict")]
443 return _serde::__private::Err(
444 <__A::Error as _serde::de::Error>::duplicate_field(
445 "bindings",
446 ),
447 );
448 }
449 m_bindings = _serde::__private::Some(
450 match __A::next_value::<Vec<Pointer>>(&mut __map) {
451 _serde::__private::Ok(__val) => __val,
452 _serde::__private::Err(__err) => {
453 return _serde::__private::Err(__err);
454 }
455 },
456 );
457 }
458 __Field::m_attachments => {
459 #[cfg(
460 any(feature = "strict", feature = "ignore_duplicates")
461 )]
462 if _serde::__private::Option::is_some(&m_attachments) {
463 #[cfg(feature = "ignore_duplicates")]
464 {
465 __A::skip_value(&mut __map)?;
466 continue;
467 }
468 #[cfg(feature = "strict")]
469 return _serde::__private::Err(
470 <__A::Error as _serde::de::Error>::duplicate_field(
471 "attachments",
472 ),
473 );
474 }
475 m_attachments = _serde::__private::Some(
476 match __A::next_value::<Vec<Pointer>>(&mut __map) {
477 _serde::__private::Ok(__val) => __val,
478 _serde::__private::Err(__err) => {
479 return _serde::__private::Err(__err);
480 }
481 },
482 );
483 }
484 __Field::m_skins => {
485 #[cfg(
486 any(feature = "strict", feature = "ignore_duplicates")
487 )]
488 if _serde::__private::Option::is_some(&m_skins) {
489 #[cfg(feature = "ignore_duplicates")]
490 {
491 __A::skip_value(&mut __map)?;
492 continue;
493 }
494 #[cfg(feature = "strict")]
495 return _serde::__private::Err(
496 <__A::Error as _serde::de::Error>::duplicate_field("skins"),
497 );
498 }
499 m_skins = _serde::__private::Some(
500 match __A::next_value::<Vec<Pointer>>(&mut __map) {
501 _serde::__private::Ok(__val) => __val,
502 _serde::__private::Err(__err) => {
503 return _serde::__private::Err(__err);
504 }
505 },
506 );
507 }
508 _ => __A::skip_value(&mut __map)?,
509 }
510 }
511 let m_skeletons = match m_skeletons {
512 _serde::__private::Some(__field) => __field,
513 _serde::__private::None => {
514 #[cfg(feature = "strict")]
515 return _serde::__private::Err(
516 <__A::Error as _serde::de::Error>::missing_field(
517 "skeletons",
518 ),
519 );
520 #[cfg(not(feature = "strict"))] Default::default()
521 }
522 };
523 let m_animations = match m_animations {
524 _serde::__private::Some(__field) => __field,
525 _serde::__private::None => {
526 #[cfg(feature = "strict")]
527 return _serde::__private::Err(
528 <__A::Error as _serde::de::Error>::missing_field(
529 "animations",
530 ),
531 );
532 #[cfg(not(feature = "strict"))] Default::default()
533 }
534 };
535 let m_bindings = match m_bindings {
536 _serde::__private::Some(__field) => __field,
537 _serde::__private::None => {
538 #[cfg(feature = "strict")]
539 return _serde::__private::Err(
540 <__A::Error as _serde::de::Error>::missing_field("bindings"),
541 );
542 #[cfg(not(feature = "strict"))] Default::default()
543 }
544 };
545 let m_attachments = match m_attachments {
546 _serde::__private::Some(__field) => __field,
547 _serde::__private::None => {
548 #[cfg(feature = "strict")]
549 return _serde::__private::Err(
550 <__A::Error as _serde::de::Error>::missing_field(
551 "attachments",
552 ),
553 );
554 #[cfg(not(feature = "strict"))] Default::default()
555 }
556 };
557 let m_skins = match m_skins {
558 _serde::__private::Some(__field) => __field,
559 _serde::__private::None => {
560 #[cfg(feature = "strict")]
561 return _serde::__private::Err(
562 <__A::Error as _serde::de::Error>::missing_field("skins"),
563 );
564 #[cfg(not(feature = "strict"))] Default::default()
565 }
566 };
567 let __ptr = None;
568 let parent = hkBaseObject { __ptr };
569 let parent = hkReferencedObject {
570 __ptr,
571 parent,
572 ..Default::default()
573 };
574 let __ptr = __A::class_ptr(&mut __map);
575 _serde::__private::Ok(hkaAnimationContainer {
576 __ptr,
577 parent,
578 m_skeletons,
579 m_animations,
580 m_bindings,
581 m_attachments,
582 m_skins,
583 })
584 }
585 }
586 const FIELDS: &[&str] = &[
587 "skeletons",
588 "animations",
589 "bindings",
590 "attachments",
591 "skins",
592 ];
593 _serde::Deserializer::deserialize_struct(
594 deserializer,
595 "hkaAnimationContainer",
596 FIELDS,
597 __hkaAnimationContainerVisitor {
598 marker: _serde::__private::PhantomData::<hkaAnimationContainer>,
599 lifetime: _serde::__private::PhantomData,
600 },
601 )
602 }
603 }
604};