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