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