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