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