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 hkpExtendedMeshShape {
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 = "embeddedTrianglesSubpart"))]
35 #[cfg_attr(feature = "serde", serde(rename = "embeddedTrianglesSubpart"))]
36 pub m_embeddedTrianglesSubpart: hkpExtendedMeshShapeTrianglesSubpart,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "aabbHalfExtents"))]
42 #[cfg_attr(feature = "serde", serde(rename = "aabbHalfExtents"))]
43 pub m_aabbHalfExtents: Vector4,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "aabbCenter"))]
49 #[cfg_attr(feature = "serde", serde(rename = "aabbCenter"))]
50 pub m_aabbCenter: Vector4,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "materialClass"))]
57 #[cfg_attr(feature = "serde", serde(rename = "materialClass"))]
58 pub m_materialClass: Pointer,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "numBitsForSubpartIndex"))]
64 #[cfg_attr(feature = "serde", serde(rename = "numBitsForSubpartIndex"))]
65 pub m_numBitsForSubpartIndex: i32,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "trianglesSubparts"))]
71 #[cfg_attr(feature = "serde", serde(rename = "trianglesSubparts"))]
72 pub m_trianglesSubparts: Vec<hkpExtendedMeshShapeTrianglesSubpart>,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "shapesSubparts"))]
78 #[cfg_attr(feature = "serde", serde(rename = "shapesSubparts"))]
79 pub m_shapesSubparts: Vec<hkpExtendedMeshShapeShapesSubpart>,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "weldingInfo"))]
85 #[cfg_attr(feature = "serde", serde(rename = "weldingInfo"))]
86 pub m_weldingInfo: Vec<u16>,
87 #[cfg_attr(feature = "json_schema", schemars(rename = "weldingType"))]
92 #[cfg_attr(feature = "serde", serde(rename = "weldingType"))]
93 pub m_weldingType: WeldingType,
94 #[cfg_attr(feature = "json_schema", schemars(rename = "defaultCollisionFilterInfo"))]
99 #[cfg_attr(feature = "serde", serde(rename = "defaultCollisionFilterInfo"))]
100 pub m_defaultCollisionFilterInfo: u32,
101 #[cfg_attr(feature = "json_schema", schemars(rename = "cachedNumChildShapes"))]
106 #[cfg_attr(feature = "serde", serde(rename = "cachedNumChildShapes"))]
107 pub m_cachedNumChildShapes: i32,
108 #[cfg_attr(feature = "json_schema", schemars(rename = "triangleRadius"))]
113 #[cfg_attr(feature = "serde", serde(rename = "triangleRadius"))]
114 pub m_triangleRadius: f32,
115 #[cfg_attr(feature = "json_schema", schemars(rename = "padding"))]
121 #[cfg_attr(feature = "serde", serde(rename = "padding"))]
122 pub m_padding: i32,
123}
124const _: () = {
125 use havok_serde as _serde;
126 impl _serde::HavokClass for hkpExtendedMeshShape {
127 #[inline]
128 fn name(&self) -> &'static str {
129 "hkpExtendedMeshShape"
130 }
131 #[inline]
132 fn signature(&self) -> _serde::__private::Signature {
133 _serde::__private::Signature::new(0x177114a2)
134 }
135 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
136 fn deps_indexes(&self) -> Vec<usize> {
137 let mut v = Vec::new();
138 v.extend(self.m_embeddedTrianglesSubpart.deps_indexes());
139 v.push(self.m_materialClass.get());
140 v.extend(
141 self
142 .m_trianglesSubparts
143 .iter()
144 .flat_map(|class| class.deps_indexes())
145 .collect::<Vec<usize>>(),
146 );
147 v.extend(
148 self
149 .m_shapesSubparts
150 .iter()
151 .flat_map(|class| class.deps_indexes())
152 .collect::<Vec<usize>>(),
153 );
154 v
155 }
156 }
157 impl _serde::Serialize for hkpExtendedMeshShape {
158 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
159 where
160 S: _serde::ser::Serializer,
161 {
162 let class_meta = self
163 .__ptr
164 .map(|name| (name, _serde::__private::Signature::new(0x177114a2)));
165 let mut serializer = __serializer
166 .serialize_struct("hkpExtendedMeshShape", class_meta, (240u64, 336u64))?;
167 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
168 serializer
169 .skip_field(
170 "memSizeAndFlags",
171 &self.parent.parent.parent.m_memSizeAndFlags,
172 )?;
173 serializer
174 .skip_field(
175 "referenceCount",
176 &self.parent.parent.parent.m_referenceCount,
177 )?;
178 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
179 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
180 serializer.skip_field("type", &self.parent.parent.m_type)?;
181 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
182 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
183 serializer.serialize_field("disableWelding", &self.parent.m_disableWelding)?;
184 serializer.serialize_field("collectionType", &self.parent.m_collectionType)?;
185 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 6usize].as_slice())?;
186 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
187 serializer
188 .serialize_field(
189 "embeddedTrianglesSubpart",
190 &self.m_embeddedTrianglesSubpart,
191 )?;
192 serializer.serialize_field("aabbHalfExtents", &self.m_aabbHalfExtents)?;
193 serializer.serialize_field("aabbCenter", &self.m_aabbCenter)?;
194 serializer.skip_field("materialClass", &self.m_materialClass)?;
195 serializer
196 .serialize_field(
197 "numBitsForSubpartIndex",
198 &self.m_numBitsForSubpartIndex,
199 )?;
200 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
201 serializer
202 .serialize_array_field(
203 "trianglesSubparts",
204 &self.m_trianglesSubparts,
205 TypeSize::Struct {
206 size_x86: 112u64,
207 size_x86_64: 160u64,
208 },
209 )?;
210 serializer
211 .serialize_array_field(
212 "shapesSubparts",
213 &self.m_shapesSubparts,
214 TypeSize::Struct {
215 size_x86: 64u64,
216 size_x86_64: 96u64,
217 },
218 )?;
219 serializer
220 .serialize_array_field(
221 "weldingInfo",
222 &self.m_weldingInfo,
223 TypeSize::NonPtr,
224 )?;
225 serializer.serialize_field("weldingType", &self.m_weldingType)?;
226 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
227 serializer
228 .serialize_field(
229 "defaultCollisionFilterInfo",
230 &self.m_defaultCollisionFilterInfo,
231 )?;
232 serializer
233 .serialize_field("cachedNumChildShapes", &self.m_cachedNumChildShapes)?;
234 serializer.serialize_field("triangleRadius", &self.m_triangleRadius)?;
235 serializer.skip_field("padding", &self.m_padding)?;
236 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 12usize].as_slice())?;
237 serializer.end()
238 }
239 }
240};
241#[doc(hidden)]
242#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
243const _: () = {
244 use havok_serde as _serde;
245 #[automatically_derived]
246 impl<'de> _serde::Deserialize<'de> for hkpExtendedMeshShape {
247 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
248 where
249 __D: _serde::Deserializer<'de>,
250 {
251 #[allow(non_camel_case_types)]
252 enum __Field {
253 m_userData,
254 m_disableWelding,
255 m_collectionType,
256 m_embeddedTrianglesSubpart,
257 m_aabbHalfExtents,
258 m_aabbCenter,
259 m_numBitsForSubpartIndex,
260 m_trianglesSubparts,
261 m_shapesSubparts,
262 m_weldingInfo,
263 m_weldingType,
264 m_defaultCollisionFilterInfo,
265 m_cachedNumChildShapes,
266 m_triangleRadius,
267 __ignore,
268 }
269 struct __FieldVisitor;
270 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
271 type Value = __Field;
272 fn expecting(
273 &self,
274 __formatter: &mut core::fmt::Formatter,
275 ) -> core::fmt::Result {
276 core::fmt::Formatter::write_str(__formatter, "field identifier")
277 }
278 #[allow(clippy::match_single_binding)]
280 #[allow(clippy::reversed_empty_ranges)]
281 #[allow(clippy::single_match)]
282 fn visit_key<__E>(
283 self,
284 __value: &str,
285 ) -> core::result::Result<Self::Value, __E>
286 where
287 __E: _serde::de::Error,
288 {
289 match __value {
290 "userData" => Ok(__Field::m_userData),
291 "disableWelding" => Ok(__Field::m_disableWelding),
292 "collectionType" => Ok(__Field::m_collectionType),
293 "embeddedTrianglesSubpart" => {
294 Ok(__Field::m_embeddedTrianglesSubpart)
295 }
296 "aabbHalfExtents" => Ok(__Field::m_aabbHalfExtents),
297 "aabbCenter" => Ok(__Field::m_aabbCenter),
298 "numBitsForSubpartIndex" => Ok(__Field::m_numBitsForSubpartIndex),
299 "trianglesSubparts" => Ok(__Field::m_trianglesSubparts),
300 "shapesSubparts" => Ok(__Field::m_shapesSubparts),
301 "weldingInfo" => Ok(__Field::m_weldingInfo),
302 "weldingType" => Ok(__Field::m_weldingType),
303 "defaultCollisionFilterInfo" => {
304 Ok(__Field::m_defaultCollisionFilterInfo)
305 }
306 "cachedNumChildShapes" => Ok(__Field::m_cachedNumChildShapes),
307 "triangleRadius" => Ok(__Field::m_triangleRadius),
308 _ => Ok(__Field::__ignore),
309 }
310 }
311 }
312 impl<'de> _serde::Deserialize<'de> for __Field {
313 #[inline]
314 fn deserialize<__D>(
315 __deserializer: __D,
316 ) -> core::result::Result<Self, __D::Error>
317 where
318 __D: _serde::Deserializer<'de>,
319 {
320 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
321 }
322 }
323 struct __hkpExtendedMeshShapeVisitor<'de> {
324 marker: _serde::__private::PhantomData<hkpExtendedMeshShape>,
325 lifetime: _serde::__private::PhantomData<&'de ()>,
326 }
327 #[allow(clippy::match_single_binding)]
328 #[allow(clippy::reversed_empty_ranges)]
329 #[allow(clippy::single_match)]
330 impl<'de> _serde::de::Visitor<'de> for __hkpExtendedMeshShapeVisitor<'de> {
331 type Value = hkpExtendedMeshShape;
332 fn expecting(
333 &self,
334 __formatter: &mut core::fmt::Formatter,
335 ) -> core::fmt::Result {
336 core::fmt::Formatter::write_str(
337 __formatter,
338 "struct hkpExtendedMeshShape",
339 )
340 }
341 fn visit_struct_for_bytes<__A>(
342 self,
343 mut __map: __A,
344 ) -> _serde::__private::Result<Self::Value, __A::Error>
345 where
346 __A: _serde::de::MapAccess<'de>,
347 {
348 let __ptr = __A::class_ptr(&mut __map);
349 let parent = __A::parent_value(&mut __map)?;
350 let mut m_embeddedTrianglesSubpart: _serde::__private::Option<
351 hkpExtendedMeshShapeTrianglesSubpart,
352 > = _serde::__private::None;
353 let mut m_aabbHalfExtents: _serde::__private::Option<Vector4> = _serde::__private::None;
354 let mut m_aabbCenter: _serde::__private::Option<Vector4> = _serde::__private::None;
355 let mut m_materialClass: _serde::__private::Option<Pointer> = _serde::__private::None;
356 let mut m_numBitsForSubpartIndex: _serde::__private::Option<i32> = _serde::__private::None;
357 let mut m_trianglesSubparts: _serde::__private::Option<
358 Vec<hkpExtendedMeshShapeTrianglesSubpart>,
359 > = _serde::__private::None;
360 let mut m_shapesSubparts: _serde::__private::Option<
361 Vec<hkpExtendedMeshShapeShapesSubpart>,
362 > = _serde::__private::None;
363 let mut m_weldingInfo: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
364 let mut m_weldingType: _serde::__private::Option<WeldingType> = _serde::__private::None;
365 let mut m_defaultCollisionFilterInfo: _serde::__private::Option<
366 u32,
367 > = _serde::__private::None;
368 let mut m_cachedNumChildShapes: _serde::__private::Option<i32> = _serde::__private::None;
369 let mut m_triangleRadius: _serde::__private::Option<f32> = _serde::__private::None;
370 let mut m_padding: _serde::__private::Option<i32> = _serde::__private::None;
371 for i in 0..13usize {
372 match i {
373 0usize => {
374 if _serde::__private::Option::is_some(
375 &m_embeddedTrianglesSubpart,
376 ) {
377 return _serde::__private::Err(
378 <__A::Error as _serde::de::Error>::duplicate_field(
379 "embeddedTrianglesSubpart",
380 ),
381 );
382 }
383 __A::pad(&mut __map, 8usize, 0usize)?;
384 m_embeddedTrianglesSubpart = _serde::__private::Some(
385 match __A::next_value::<
386 hkpExtendedMeshShapeTrianglesSubpart,
387 >(&mut __map) {
388 _serde::__private::Ok(__val) => __val,
389 _serde::__private::Err(__err) => {
390 return _serde::__private::Err(__err);
391 }
392 },
393 );
394 }
395 1usize => {
396 if _serde::__private::Option::is_some(&m_aabbHalfExtents) {
397 return _serde::__private::Err(
398 <__A::Error as _serde::de::Error>::duplicate_field(
399 "aabbHalfExtents",
400 ),
401 );
402 }
403 m_aabbHalfExtents = _serde::__private::Some(
404 match __A::next_value::<Vector4>(&mut __map) {
405 _serde::__private::Ok(__val) => __val,
406 _serde::__private::Err(__err) => {
407 return _serde::__private::Err(__err);
408 }
409 },
410 );
411 }
412 2usize => {
413 if _serde::__private::Option::is_some(&m_aabbCenter) {
414 return _serde::__private::Err(
415 <__A::Error as _serde::de::Error>::duplicate_field(
416 "aabbCenter",
417 ),
418 );
419 }
420 m_aabbCenter = _serde::__private::Some(
421 match __A::next_value::<Vector4>(&mut __map) {
422 _serde::__private::Ok(__val) => __val,
423 _serde::__private::Err(__err) => {
424 return _serde::__private::Err(__err);
425 }
426 },
427 );
428 }
429 3usize => {
430 if _serde::__private::Option::is_some(&m_materialClass) {
431 return _serde::__private::Err(
432 <__A::Error as _serde::de::Error>::duplicate_field(
433 "materialClass",
434 ),
435 );
436 }
437 m_materialClass = _serde::__private::Some(
438 match __A::next_value::<Pointer>(&mut __map) {
439 _serde::__private::Ok(__val) => __val,
440 _serde::__private::Err(__err) => {
441 return _serde::__private::Err(__err);
442 }
443 },
444 );
445 }
446 4usize => {
447 if _serde::__private::Option::is_some(
448 &m_numBitsForSubpartIndex,
449 ) {
450 return _serde::__private::Err(
451 <__A::Error as _serde::de::Error>::duplicate_field(
452 "numBitsForSubpartIndex",
453 ),
454 );
455 }
456 m_numBitsForSubpartIndex = _serde::__private::Some(
457 match __A::next_value::<i32>(&mut __map) {
458 _serde::__private::Ok(__val) => __val,
459 _serde::__private::Err(__err) => {
460 return _serde::__private::Err(__err);
461 }
462 },
463 );
464 }
465 5usize => {
466 if _serde::__private::Option::is_some(
467 &m_trianglesSubparts,
468 ) {
469 return _serde::__private::Err(
470 <__A::Error as _serde::de::Error>::duplicate_field(
471 "trianglesSubparts",
472 ),
473 );
474 }
475 __A::pad(&mut __map, 0usize, 4usize)?;
476 m_trianglesSubparts = _serde::__private::Some(
477 match __A::next_value::<
478 Vec<hkpExtendedMeshShapeTrianglesSubpart>,
479 >(&mut __map) {
480 _serde::__private::Ok(__val) => __val,
481 _serde::__private::Err(__err) => {
482 return _serde::__private::Err(__err);
483 }
484 },
485 );
486 }
487 6usize => {
488 if _serde::__private::Option::is_some(&m_shapesSubparts) {
489 return _serde::__private::Err(
490 <__A::Error as _serde::de::Error>::duplicate_field(
491 "shapesSubparts",
492 ),
493 );
494 }
495 m_shapesSubparts = _serde::__private::Some(
496 match __A::next_value::<
497 Vec<hkpExtendedMeshShapeShapesSubpart>,
498 >(&mut __map) {
499 _serde::__private::Ok(__val) => __val,
500 _serde::__private::Err(__err) => {
501 return _serde::__private::Err(__err);
502 }
503 },
504 );
505 }
506 7usize => {
507 if _serde::__private::Option::is_some(&m_weldingInfo) {
508 return _serde::__private::Err(
509 <__A::Error as _serde::de::Error>::duplicate_field(
510 "weldingInfo",
511 ),
512 );
513 }
514 m_weldingInfo = _serde::__private::Some(
515 match __A::next_value::<Vec<u16>>(&mut __map) {
516 _serde::__private::Ok(__val) => __val,
517 _serde::__private::Err(__err) => {
518 return _serde::__private::Err(__err);
519 }
520 },
521 );
522 }
523 8usize => {
524 if _serde::__private::Option::is_some(&m_weldingType) {
525 return _serde::__private::Err(
526 <__A::Error as _serde::de::Error>::duplicate_field(
527 "weldingType",
528 ),
529 );
530 }
531 m_weldingType = _serde::__private::Some(
532 match __A::next_value::<WeldingType>(&mut __map) {
533 _serde::__private::Ok(__val) => __val,
534 _serde::__private::Err(__err) => {
535 return _serde::__private::Err(__err);
536 }
537 },
538 );
539 }
540 9usize => {
541 if _serde::__private::Option::is_some(
542 &m_defaultCollisionFilterInfo,
543 ) {
544 return _serde::__private::Err(
545 <__A::Error as _serde::de::Error>::duplicate_field(
546 "defaultCollisionFilterInfo",
547 ),
548 );
549 }
550 __A::pad(&mut __map, 3usize, 3usize)?;
551 m_defaultCollisionFilterInfo = _serde::__private::Some(
552 match __A::next_value::<u32>(&mut __map) {
553 _serde::__private::Ok(__val) => __val,
554 _serde::__private::Err(__err) => {
555 return _serde::__private::Err(__err);
556 }
557 },
558 );
559 }
560 10usize => {
561 if _serde::__private::Option::is_some(
562 &m_cachedNumChildShapes,
563 ) {
564 return _serde::__private::Err(
565 <__A::Error as _serde::de::Error>::duplicate_field(
566 "cachedNumChildShapes",
567 ),
568 );
569 }
570 m_cachedNumChildShapes = _serde::__private::Some(
571 match __A::next_value::<i32>(&mut __map) {
572 _serde::__private::Ok(__val) => __val,
573 _serde::__private::Err(__err) => {
574 return _serde::__private::Err(__err);
575 }
576 },
577 );
578 }
579 11usize => {
580 if _serde::__private::Option::is_some(&m_triangleRadius) {
581 return _serde::__private::Err(
582 <__A::Error as _serde::de::Error>::duplicate_field(
583 "triangleRadius",
584 ),
585 );
586 }
587 m_triangleRadius = _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 12usize => {
597 if _serde::__private::Option::is_some(&m_padding) {
598 return _serde::__private::Err(
599 <__A::Error as _serde::de::Error>::duplicate_field(
600 "padding",
601 ),
602 );
603 }
604 m_padding = _serde::__private::Some(
605 match __A::next_value::<i32>(&mut __map) {
606 _serde::__private::Ok(__val) => __val,
607 _serde::__private::Err(__err) => {
608 return _serde::__private::Err(__err);
609 }
610 },
611 );
612 }
613 _ => {}
614 }
615 }
616 __A::pad(&mut __map, 0usize, 12usize)?;
617 let m_embeddedTrianglesSubpart = match m_embeddedTrianglesSubpart {
618 _serde::__private::Some(__field) => __field,
619 _serde::__private::None => {
620 return _serde::__private::Err(
621 <__A::Error as _serde::de::Error>::missing_field(
622 "embeddedTrianglesSubpart",
623 ),
624 );
625 }
626 };
627 let m_aabbHalfExtents = match m_aabbHalfExtents {
628 _serde::__private::Some(__field) => __field,
629 _serde::__private::None => {
630 return _serde::__private::Err(
631 <__A::Error as _serde::de::Error>::missing_field(
632 "aabbHalfExtents",
633 ),
634 );
635 }
636 };
637 let m_aabbCenter = match m_aabbCenter {
638 _serde::__private::Some(__field) => __field,
639 _serde::__private::None => {
640 return _serde::__private::Err(
641 <__A::Error as _serde::de::Error>::missing_field(
642 "aabbCenter",
643 ),
644 );
645 }
646 };
647 let m_materialClass = match m_materialClass {
648 _serde::__private::Some(__field) => __field,
649 _serde::__private::None => {
650 return _serde::__private::Err(
651 <__A::Error as _serde::de::Error>::missing_field(
652 "materialClass",
653 ),
654 );
655 }
656 };
657 let m_numBitsForSubpartIndex = match m_numBitsForSubpartIndex {
658 _serde::__private::Some(__field) => __field,
659 _serde::__private::None => {
660 return _serde::__private::Err(
661 <__A::Error as _serde::de::Error>::missing_field(
662 "numBitsForSubpartIndex",
663 ),
664 );
665 }
666 };
667 let m_trianglesSubparts = match m_trianglesSubparts {
668 _serde::__private::Some(__field) => __field,
669 _serde::__private::None => {
670 return _serde::__private::Err(
671 <__A::Error as _serde::de::Error>::missing_field(
672 "trianglesSubparts",
673 ),
674 );
675 }
676 };
677 let m_shapesSubparts = match m_shapesSubparts {
678 _serde::__private::Some(__field) => __field,
679 _serde::__private::None => {
680 return _serde::__private::Err(
681 <__A::Error as _serde::de::Error>::missing_field(
682 "shapesSubparts",
683 ),
684 );
685 }
686 };
687 let m_weldingInfo = match m_weldingInfo {
688 _serde::__private::Some(__field) => __field,
689 _serde::__private::None => {
690 return _serde::__private::Err(
691 <__A::Error as _serde::de::Error>::missing_field(
692 "weldingInfo",
693 ),
694 );
695 }
696 };
697 let m_weldingType = match m_weldingType {
698 _serde::__private::Some(__field) => __field,
699 _serde::__private::None => {
700 return _serde::__private::Err(
701 <__A::Error as _serde::de::Error>::missing_field(
702 "weldingType",
703 ),
704 );
705 }
706 };
707 let m_defaultCollisionFilterInfo = match m_defaultCollisionFilterInfo {
708 _serde::__private::Some(__field) => __field,
709 _serde::__private::None => {
710 return _serde::__private::Err(
711 <__A::Error as _serde::de::Error>::missing_field(
712 "defaultCollisionFilterInfo",
713 ),
714 );
715 }
716 };
717 let m_cachedNumChildShapes = match m_cachedNumChildShapes {
718 _serde::__private::Some(__field) => __field,
719 _serde::__private::None => {
720 return _serde::__private::Err(
721 <__A::Error as _serde::de::Error>::missing_field(
722 "cachedNumChildShapes",
723 ),
724 );
725 }
726 };
727 let m_triangleRadius = match m_triangleRadius {
728 _serde::__private::Some(__field) => __field,
729 _serde::__private::None => {
730 return _serde::__private::Err(
731 <__A::Error as _serde::de::Error>::missing_field(
732 "triangleRadius",
733 ),
734 );
735 }
736 };
737 let m_padding = match m_padding {
738 _serde::__private::Some(__field) => __field,
739 _serde::__private::None => {
740 return _serde::__private::Err(
741 <__A::Error as _serde::de::Error>::missing_field("padding"),
742 );
743 }
744 };
745 _serde::__private::Ok(hkpExtendedMeshShape {
746 __ptr,
747 parent,
748 m_embeddedTrianglesSubpart,
749 m_aabbHalfExtents,
750 m_aabbCenter,
751 m_materialClass,
752 m_numBitsForSubpartIndex,
753 m_trianglesSubparts,
754 m_shapesSubparts,
755 m_weldingInfo,
756 m_weldingType,
757 m_defaultCollisionFilterInfo,
758 m_cachedNumChildShapes,
759 m_triangleRadius,
760 m_padding,
761 })
762 }
763 #[allow(clippy::manual_unwrap_or_default)]
764 fn visit_struct<__A>(
765 self,
766 mut __map: __A,
767 ) -> _serde::__private::Result<Self::Value, __A::Error>
768 where
769 __A: _serde::de::MapAccess<'de>,
770 {
771 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
772 let mut m_disableWelding: _serde::__private::Option<bool> = _serde::__private::None;
773 let mut m_collectionType: _serde::__private::Option<
774 CollectionType,
775 > = _serde::__private::None;
776 let mut m_embeddedTrianglesSubpart: _serde::__private::Option<
777 hkpExtendedMeshShapeTrianglesSubpart,
778 > = _serde::__private::None;
779 let mut m_aabbHalfExtents: _serde::__private::Option<Vector4> = _serde::__private::None;
780 let mut m_aabbCenter: _serde::__private::Option<Vector4> = _serde::__private::None;
781 let mut m_numBitsForSubpartIndex: _serde::__private::Option<i32> = _serde::__private::None;
782 let mut m_trianglesSubparts: _serde::__private::Option<
783 Vec<hkpExtendedMeshShapeTrianglesSubpart>,
784 > = _serde::__private::None;
785 let mut m_shapesSubparts: _serde::__private::Option<
786 Vec<hkpExtendedMeshShapeShapesSubpart>,
787 > = _serde::__private::None;
788 let mut m_weldingInfo: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
789 let mut m_weldingType: _serde::__private::Option<WeldingType> = _serde::__private::None;
790 let mut m_defaultCollisionFilterInfo: _serde::__private::Option<
791 u32,
792 > = _serde::__private::None;
793 let mut m_cachedNumChildShapes: _serde::__private::Option<i32> = _serde::__private::None;
794 let mut m_triangleRadius: _serde::__private::Option<f32> = _serde::__private::None;
795 while let _serde::__private::Some(__key) = {
796 __A::next_key::<__Field>(&mut __map)?
797 } {
798 match __key {
799 __Field::m_userData => {
800 #[cfg(
801 any(feature = "strict", feature = "ignore_duplicates")
802 )]
803 if _serde::__private::Option::is_some(&m_userData) {
804 #[cfg(feature = "ignore_duplicates")]
805 {
806 __A::skip_value(&mut __map)?;
807 continue;
808 }
809 #[cfg(feature = "strict")]
810 return _serde::__private::Err(
811 <__A::Error as _serde::de::Error>::duplicate_field(
812 "userData",
813 ),
814 );
815 }
816 m_userData = _serde::__private::Some(
817 match __A::next_value::<Ulong>(&mut __map) {
818 _serde::__private::Ok(__val) => __val,
819 _serde::__private::Err(__err) => {
820 return _serde::__private::Err(__err);
821 }
822 },
823 );
824 }
825 __Field::m_disableWelding => {
826 #[cfg(
827 any(feature = "strict", feature = "ignore_duplicates")
828 )]
829 if _serde::__private::Option::is_some(&m_disableWelding) {
830 #[cfg(feature = "ignore_duplicates")]
831 {
832 __A::skip_value(&mut __map)?;
833 continue;
834 }
835 #[cfg(feature = "strict")]
836 return _serde::__private::Err(
837 <__A::Error as _serde::de::Error>::duplicate_field(
838 "disableWelding",
839 ),
840 );
841 }
842 m_disableWelding = _serde::__private::Some(
843 match __A::next_value::<bool>(&mut __map) {
844 _serde::__private::Ok(__val) => __val,
845 _serde::__private::Err(__err) => {
846 return _serde::__private::Err(__err);
847 }
848 },
849 );
850 }
851 __Field::m_collectionType => {
852 #[cfg(
853 any(feature = "strict", feature = "ignore_duplicates")
854 )]
855 if _serde::__private::Option::is_some(&m_collectionType) {
856 #[cfg(feature = "ignore_duplicates")]
857 {
858 __A::skip_value(&mut __map)?;
859 continue;
860 }
861 #[cfg(feature = "strict")]
862 return _serde::__private::Err(
863 <__A::Error as _serde::de::Error>::duplicate_field(
864 "collectionType",
865 ),
866 );
867 }
868 m_collectionType = _serde::__private::Some(
869 match __A::next_value::<CollectionType>(&mut __map) {
870 _serde::__private::Ok(__val) => __val,
871 _serde::__private::Err(__err) => {
872 return _serde::__private::Err(__err);
873 }
874 },
875 );
876 }
877 __Field::m_embeddedTrianglesSubpart => {
878 #[cfg(
879 any(feature = "strict", feature = "ignore_duplicates")
880 )]
881 if _serde::__private::Option::is_some(
882 &m_embeddedTrianglesSubpart,
883 ) {
884 #[cfg(feature = "ignore_duplicates")]
885 {
886 __A::skip_value(&mut __map)?;
887 continue;
888 }
889 #[cfg(feature = "strict")]
890 return _serde::__private::Err(
891 <__A::Error as _serde::de::Error>::duplicate_field(
892 "embeddedTrianglesSubpart",
893 ),
894 );
895 }
896 m_embeddedTrianglesSubpart = _serde::__private::Some(
897 match __A::next_value::<
898 hkpExtendedMeshShapeTrianglesSubpart,
899 >(&mut __map) {
900 _serde::__private::Ok(__val) => __val,
901 _serde::__private::Err(__err) => {
902 return _serde::__private::Err(__err);
903 }
904 },
905 );
906 }
907 __Field::m_aabbHalfExtents => {
908 #[cfg(
909 any(feature = "strict", feature = "ignore_duplicates")
910 )]
911 if _serde::__private::Option::is_some(&m_aabbHalfExtents) {
912 #[cfg(feature = "ignore_duplicates")]
913 {
914 __A::skip_value(&mut __map)?;
915 continue;
916 }
917 #[cfg(feature = "strict")]
918 return _serde::__private::Err(
919 <__A::Error as _serde::de::Error>::duplicate_field(
920 "aabbHalfExtents",
921 ),
922 );
923 }
924 m_aabbHalfExtents = _serde::__private::Some(
925 match __A::next_value::<Vector4>(&mut __map) {
926 _serde::__private::Ok(__val) => __val,
927 _serde::__private::Err(__err) => {
928 return _serde::__private::Err(__err);
929 }
930 },
931 );
932 }
933 __Field::m_aabbCenter => {
934 #[cfg(
935 any(feature = "strict", feature = "ignore_duplicates")
936 )]
937 if _serde::__private::Option::is_some(&m_aabbCenter) {
938 #[cfg(feature = "ignore_duplicates")]
939 {
940 __A::skip_value(&mut __map)?;
941 continue;
942 }
943 #[cfg(feature = "strict")]
944 return _serde::__private::Err(
945 <__A::Error as _serde::de::Error>::duplicate_field(
946 "aabbCenter",
947 ),
948 );
949 }
950 m_aabbCenter = _serde::__private::Some(
951 match __A::next_value::<Vector4>(&mut __map) {
952 _serde::__private::Ok(__val) => __val,
953 _serde::__private::Err(__err) => {
954 return _serde::__private::Err(__err);
955 }
956 },
957 );
958 }
959 __Field::m_numBitsForSubpartIndex => {
960 #[cfg(
961 any(feature = "strict", feature = "ignore_duplicates")
962 )]
963 if _serde::__private::Option::is_some(
964 &m_numBitsForSubpartIndex,
965 ) {
966 #[cfg(feature = "ignore_duplicates")]
967 {
968 __A::skip_value(&mut __map)?;
969 continue;
970 }
971 #[cfg(feature = "strict")]
972 return _serde::__private::Err(
973 <__A::Error as _serde::de::Error>::duplicate_field(
974 "numBitsForSubpartIndex",
975 ),
976 );
977 }
978 m_numBitsForSubpartIndex = _serde::__private::Some(
979 match __A::next_value::<i32>(&mut __map) {
980 _serde::__private::Ok(__val) => __val,
981 _serde::__private::Err(__err) => {
982 return _serde::__private::Err(__err);
983 }
984 },
985 );
986 }
987 __Field::m_trianglesSubparts => {
988 #[cfg(
989 any(feature = "strict", feature = "ignore_duplicates")
990 )]
991 if _serde::__private::Option::is_some(
992 &m_trianglesSubparts,
993 ) {
994 #[cfg(feature = "ignore_duplicates")]
995 {
996 __A::skip_value(&mut __map)?;
997 continue;
998 }
999 #[cfg(feature = "strict")]
1000 return _serde::__private::Err(
1001 <__A::Error as _serde::de::Error>::duplicate_field(
1002 "trianglesSubparts",
1003 ),
1004 );
1005 }
1006 m_trianglesSubparts = _serde::__private::Some(
1007 match __A::next_value::<
1008 Vec<hkpExtendedMeshShapeTrianglesSubpart>,
1009 >(&mut __map) {
1010 _serde::__private::Ok(__val) => __val,
1011 _serde::__private::Err(__err) => {
1012 return _serde::__private::Err(__err);
1013 }
1014 },
1015 );
1016 }
1017 __Field::m_shapesSubparts => {
1018 #[cfg(
1019 any(feature = "strict", feature = "ignore_duplicates")
1020 )]
1021 if _serde::__private::Option::is_some(&m_shapesSubparts) {
1022 #[cfg(feature = "ignore_duplicates")]
1023 {
1024 __A::skip_value(&mut __map)?;
1025 continue;
1026 }
1027 #[cfg(feature = "strict")]
1028 return _serde::__private::Err(
1029 <__A::Error as _serde::de::Error>::duplicate_field(
1030 "shapesSubparts",
1031 ),
1032 );
1033 }
1034 m_shapesSubparts = _serde::__private::Some(
1035 match __A::next_value::<
1036 Vec<hkpExtendedMeshShapeShapesSubpart>,
1037 >(&mut __map) {
1038 _serde::__private::Ok(__val) => __val,
1039 _serde::__private::Err(__err) => {
1040 return _serde::__private::Err(__err);
1041 }
1042 },
1043 );
1044 }
1045 __Field::m_weldingInfo => {
1046 #[cfg(
1047 any(feature = "strict", feature = "ignore_duplicates")
1048 )]
1049 if _serde::__private::Option::is_some(&m_weldingInfo) {
1050 #[cfg(feature = "ignore_duplicates")]
1051 {
1052 __A::skip_value(&mut __map)?;
1053 continue;
1054 }
1055 #[cfg(feature = "strict")]
1056 return _serde::__private::Err(
1057 <__A::Error as _serde::de::Error>::duplicate_field(
1058 "weldingInfo",
1059 ),
1060 );
1061 }
1062 m_weldingInfo = _serde::__private::Some(
1063 match __A::next_value::<Vec<u16>>(&mut __map) {
1064 _serde::__private::Ok(__val) => __val,
1065 _serde::__private::Err(__err) => {
1066 return _serde::__private::Err(__err);
1067 }
1068 },
1069 );
1070 }
1071 __Field::m_weldingType => {
1072 #[cfg(
1073 any(feature = "strict", feature = "ignore_duplicates")
1074 )]
1075 if _serde::__private::Option::is_some(&m_weldingType) {
1076 #[cfg(feature = "ignore_duplicates")]
1077 {
1078 __A::skip_value(&mut __map)?;
1079 continue;
1080 }
1081 #[cfg(feature = "strict")]
1082 return _serde::__private::Err(
1083 <__A::Error as _serde::de::Error>::duplicate_field(
1084 "weldingType",
1085 ),
1086 );
1087 }
1088 m_weldingType = _serde::__private::Some(
1089 match __A::next_value::<WeldingType>(&mut __map) {
1090 _serde::__private::Ok(__val) => __val,
1091 _serde::__private::Err(__err) => {
1092 return _serde::__private::Err(__err);
1093 }
1094 },
1095 );
1096 }
1097 __Field::m_defaultCollisionFilterInfo => {
1098 #[cfg(
1099 any(feature = "strict", feature = "ignore_duplicates")
1100 )]
1101 if _serde::__private::Option::is_some(
1102 &m_defaultCollisionFilterInfo,
1103 ) {
1104 #[cfg(feature = "ignore_duplicates")]
1105 {
1106 __A::skip_value(&mut __map)?;
1107 continue;
1108 }
1109 #[cfg(feature = "strict")]
1110 return _serde::__private::Err(
1111 <__A::Error as _serde::de::Error>::duplicate_field(
1112 "defaultCollisionFilterInfo",
1113 ),
1114 );
1115 }
1116 m_defaultCollisionFilterInfo = _serde::__private::Some(
1117 match __A::next_value::<u32>(&mut __map) {
1118 _serde::__private::Ok(__val) => __val,
1119 _serde::__private::Err(__err) => {
1120 return _serde::__private::Err(__err);
1121 }
1122 },
1123 );
1124 }
1125 __Field::m_cachedNumChildShapes => {
1126 #[cfg(
1127 any(feature = "strict", feature = "ignore_duplicates")
1128 )]
1129 if _serde::__private::Option::is_some(
1130 &m_cachedNumChildShapes,
1131 ) {
1132 #[cfg(feature = "ignore_duplicates")]
1133 {
1134 __A::skip_value(&mut __map)?;
1135 continue;
1136 }
1137 #[cfg(feature = "strict")]
1138 return _serde::__private::Err(
1139 <__A::Error as _serde::de::Error>::duplicate_field(
1140 "cachedNumChildShapes",
1141 ),
1142 );
1143 }
1144 m_cachedNumChildShapes = _serde::__private::Some(
1145 match __A::next_value::<i32>(&mut __map) {
1146 _serde::__private::Ok(__val) => __val,
1147 _serde::__private::Err(__err) => {
1148 return _serde::__private::Err(__err);
1149 }
1150 },
1151 );
1152 }
1153 __Field::m_triangleRadius => {
1154 #[cfg(
1155 any(feature = "strict", feature = "ignore_duplicates")
1156 )]
1157 if _serde::__private::Option::is_some(&m_triangleRadius) {
1158 #[cfg(feature = "ignore_duplicates")]
1159 {
1160 __A::skip_value(&mut __map)?;
1161 continue;
1162 }
1163 #[cfg(feature = "strict")]
1164 return _serde::__private::Err(
1165 <__A::Error as _serde::de::Error>::duplicate_field(
1166 "triangleRadius",
1167 ),
1168 );
1169 }
1170 m_triangleRadius = _serde::__private::Some(
1171 match __A::next_value::<f32>(&mut __map) {
1172 _serde::__private::Ok(__val) => __val,
1173 _serde::__private::Err(__err) => {
1174 return _serde::__private::Err(__err);
1175 }
1176 },
1177 );
1178 }
1179 _ => __A::skip_value(&mut __map)?,
1180 }
1181 }
1182 let m_userData = match m_userData {
1183 _serde::__private::Some(__field) => __field,
1184 _serde::__private::None => {
1185 #[cfg(feature = "strict")]
1186 return _serde::__private::Err(
1187 <__A::Error as _serde::de::Error>::missing_field("userData"),
1188 );
1189 #[cfg(not(feature = "strict"))] Default::default()
1190 }
1191 };
1192 let m_disableWelding = match m_disableWelding {
1193 _serde::__private::Some(__field) => __field,
1194 _serde::__private::None => {
1195 #[cfg(feature = "strict")]
1196 return _serde::__private::Err(
1197 <__A::Error as _serde::de::Error>::missing_field(
1198 "disableWelding",
1199 ),
1200 );
1201 #[cfg(not(feature = "strict"))] Default::default()
1202 }
1203 };
1204 let m_collectionType = match m_collectionType {
1205 _serde::__private::Some(__field) => __field,
1206 _serde::__private::None => {
1207 #[cfg(feature = "strict")]
1208 return _serde::__private::Err(
1209 <__A::Error as _serde::de::Error>::missing_field(
1210 "collectionType",
1211 ),
1212 );
1213 #[cfg(not(feature = "strict"))] Default::default()
1214 }
1215 };
1216 let m_embeddedTrianglesSubpart = match m_embeddedTrianglesSubpart {
1217 _serde::__private::Some(__field) => __field,
1218 _serde::__private::None => {
1219 #[cfg(feature = "strict")]
1220 return _serde::__private::Err(
1221 <__A::Error as _serde::de::Error>::missing_field(
1222 "embeddedTrianglesSubpart",
1223 ),
1224 );
1225 #[cfg(not(feature = "strict"))] Default::default()
1226 }
1227 };
1228 let m_aabbHalfExtents = match m_aabbHalfExtents {
1229 _serde::__private::Some(__field) => __field,
1230 _serde::__private::None => {
1231 #[cfg(feature = "strict")]
1232 return _serde::__private::Err(
1233 <__A::Error as _serde::de::Error>::missing_field(
1234 "aabbHalfExtents",
1235 ),
1236 );
1237 #[cfg(not(feature = "strict"))] Default::default()
1238 }
1239 };
1240 let m_aabbCenter = match m_aabbCenter {
1241 _serde::__private::Some(__field) => __field,
1242 _serde::__private::None => {
1243 #[cfg(feature = "strict")]
1244 return _serde::__private::Err(
1245 <__A::Error as _serde::de::Error>::missing_field(
1246 "aabbCenter",
1247 ),
1248 );
1249 #[cfg(not(feature = "strict"))] Default::default()
1250 }
1251 };
1252 let m_numBitsForSubpartIndex = match m_numBitsForSubpartIndex {
1253 _serde::__private::Some(__field) => __field,
1254 _serde::__private::None => {
1255 #[cfg(feature = "strict")]
1256 return _serde::__private::Err(
1257 <__A::Error as _serde::de::Error>::missing_field(
1258 "numBitsForSubpartIndex",
1259 ),
1260 );
1261 #[cfg(not(feature = "strict"))] Default::default()
1262 }
1263 };
1264 let m_trianglesSubparts = match m_trianglesSubparts {
1265 _serde::__private::Some(__field) => __field,
1266 _serde::__private::None => {
1267 #[cfg(feature = "strict")]
1268 return _serde::__private::Err(
1269 <__A::Error as _serde::de::Error>::missing_field(
1270 "trianglesSubparts",
1271 ),
1272 );
1273 #[cfg(not(feature = "strict"))] Default::default()
1274 }
1275 };
1276 let m_shapesSubparts = match m_shapesSubparts {
1277 _serde::__private::Some(__field) => __field,
1278 _serde::__private::None => {
1279 #[cfg(feature = "strict")]
1280 return _serde::__private::Err(
1281 <__A::Error as _serde::de::Error>::missing_field(
1282 "shapesSubparts",
1283 ),
1284 );
1285 #[cfg(not(feature = "strict"))] Default::default()
1286 }
1287 };
1288 let m_weldingInfo = match m_weldingInfo {
1289 _serde::__private::Some(__field) => __field,
1290 _serde::__private::None => {
1291 #[cfg(feature = "strict")]
1292 return _serde::__private::Err(
1293 <__A::Error as _serde::de::Error>::missing_field(
1294 "weldingInfo",
1295 ),
1296 );
1297 #[cfg(not(feature = "strict"))] Default::default()
1298 }
1299 };
1300 let m_weldingType = match m_weldingType {
1301 _serde::__private::Some(__field) => __field,
1302 _serde::__private::None => {
1303 #[cfg(feature = "strict")]
1304 return _serde::__private::Err(
1305 <__A::Error as _serde::de::Error>::missing_field(
1306 "weldingType",
1307 ),
1308 );
1309 #[cfg(not(feature = "strict"))] Default::default()
1310 }
1311 };
1312 let m_defaultCollisionFilterInfo = match m_defaultCollisionFilterInfo {
1313 _serde::__private::Some(__field) => __field,
1314 _serde::__private::None => {
1315 #[cfg(feature = "strict")]
1316 return _serde::__private::Err(
1317 <__A::Error as _serde::de::Error>::missing_field(
1318 "defaultCollisionFilterInfo",
1319 ),
1320 );
1321 #[cfg(not(feature = "strict"))] Default::default()
1322 }
1323 };
1324 let m_cachedNumChildShapes = match m_cachedNumChildShapes {
1325 _serde::__private::Some(__field) => __field,
1326 _serde::__private::None => {
1327 #[cfg(feature = "strict")]
1328 return _serde::__private::Err(
1329 <__A::Error as _serde::de::Error>::missing_field(
1330 "cachedNumChildShapes",
1331 ),
1332 );
1333 #[cfg(not(feature = "strict"))] Default::default()
1334 }
1335 };
1336 let m_triangleRadius = match m_triangleRadius {
1337 _serde::__private::Some(__field) => __field,
1338 _serde::__private::None => {
1339 #[cfg(feature = "strict")]
1340 return _serde::__private::Err(
1341 <__A::Error as _serde::de::Error>::missing_field(
1342 "triangleRadius",
1343 ),
1344 );
1345 #[cfg(not(feature = "strict"))] Default::default()
1346 }
1347 };
1348 let __ptr = None;
1349 let parent = hkBaseObject { __ptr };
1350 let parent = hkReferencedObject {
1351 __ptr,
1352 parent,
1353 ..Default::default()
1354 };
1355 let parent = hkpShape {
1356 __ptr,
1357 parent,
1358 m_userData,
1359 ..Default::default()
1360 };
1361 let parent = hkpShapeCollection {
1362 __ptr,
1363 parent,
1364 m_disableWelding,
1365 m_collectionType,
1366 };
1367 let __ptr = __A::class_ptr(&mut __map);
1368 _serde::__private::Ok(hkpExtendedMeshShape {
1369 __ptr,
1370 parent,
1371 m_embeddedTrianglesSubpart,
1372 m_aabbHalfExtents,
1373 m_aabbCenter,
1374 m_numBitsForSubpartIndex,
1375 m_trianglesSubparts,
1376 m_shapesSubparts,
1377 m_weldingInfo,
1378 m_weldingType,
1379 m_defaultCollisionFilterInfo,
1380 m_cachedNumChildShapes,
1381 m_triangleRadius,
1382 ..Default::default()
1383 })
1384 }
1385 }
1386 const FIELDS: &[&str] = &[
1387 "embeddedTrianglesSubpart",
1388 "aabbHalfExtents",
1389 "aabbCenter",
1390 "materialClass",
1391 "numBitsForSubpartIndex",
1392 "trianglesSubparts",
1393 "shapesSubparts",
1394 "weldingInfo",
1395 "weldingType",
1396 "defaultCollisionFilterInfo",
1397 "cachedNumChildShapes",
1398 "triangleRadius",
1399 "padding",
1400 ];
1401 _serde::Deserializer::deserialize_struct(
1402 deserializer,
1403 "hkpExtendedMeshShape",
1404 FIELDS,
1405 __hkpExtendedMeshShapeVisitor {
1406 marker: _serde::__private::PhantomData::<hkpExtendedMeshShape>,
1407 lifetime: _serde::__private::PhantomData,
1408 },
1409 )
1410 }
1411 }
1412};
1413#[allow(non_upper_case_globals, non_snake_case)]
1416#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1417#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1418#[derive(
1419 Debug,
1420 Clone,
1421 Default,
1422 PartialEq,
1423 Eq,
1424 PartialOrd,
1425 Ord,
1426 num_derive::ToPrimitive,
1427 num_derive::FromPrimitive,
1428)]
1429pub enum IndexStridingType {
1430 #[default]
1431 INDICES_INVALID = 0isize,
1432 INDICES_INT8 = 1isize,
1433 INDICES_INT16 = 2isize,
1434 INDICES_INT32 = 3isize,
1435 INDICES_MAX_ID = 4isize,
1436}
1437#[allow(non_upper_case_globals, non_snake_case)]
1440#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1441#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1442#[derive(
1443 Debug,
1444 Clone,
1445 Default,
1446 PartialEq,
1447 Eq,
1448 PartialOrd,
1449 Ord,
1450 num_derive::ToPrimitive,
1451 num_derive::FromPrimitive,
1452)]
1453pub enum MaterialIndexStridingType {
1454 #[default]
1455 MATERIAL_INDICES_INVALID = 0isize,
1456 MATERIAL_INDICES_INT8 = 1isize,
1457 MATERIAL_INDICES_INT16 = 2isize,
1458 MATERIAL_INDICES_MAX_ID = 3isize,
1459}
1460#[allow(non_upper_case_globals, non_snake_case)]
1463#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1464#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1465#[derive(
1466 Debug,
1467 Clone,
1468 Default,
1469 PartialEq,
1470 Eq,
1471 PartialOrd,
1472 Ord,
1473 num_derive::ToPrimitive,
1474 num_derive::FromPrimitive,
1475)]
1476pub enum SubpartType {
1477 #[default]
1478 SUBPART_TRIANGLES = 0isize,
1479 SUBPART_SHAPE = 1isize,
1480}
1481const _: () = {
1482 use havok_serde as __serde;
1483 impl __serde::Serialize for IndexStridingType {
1484 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1485 where
1486 S: __serde::ser::Serializer,
1487 {
1488 let mut __serializer = __serializer.serialize_enum_flags()?;
1489 match self {
1490 Self::INDICES_INVALID => {
1491 __serializer.serialize_field("INDICES_INVALID", &0u64)
1492 }
1493 Self::INDICES_INT8 => __serializer.serialize_field("INDICES_INT8", &1u64),
1494 Self::INDICES_INT16 => {
1495 __serializer.serialize_field("INDICES_INT16", &2u64)
1496 }
1497 Self::INDICES_INT32 => {
1498 __serializer.serialize_field("INDICES_INT32", &3u64)
1499 }
1500 Self::INDICES_MAX_ID => {
1501 __serializer.serialize_field("INDICES_MAX_ID", &4u64)
1502 }
1503 }?;
1504 use num_traits::ToPrimitive as _;
1505 let num = self
1506 .to_i8()
1507 .ok_or(S::Error::custom("Failed enum IndexStridingType to_i8"))?;
1508 __serializer.serialize_bits(&num)?;
1509 __serializer.end()
1510 }
1511 }
1512};
1513const _: () = {
1514 use havok_serde as __serde;
1515 impl __serde::Serialize for MaterialIndexStridingType {
1516 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1517 where
1518 S: __serde::ser::Serializer,
1519 {
1520 let mut __serializer = __serializer.serialize_enum_flags()?;
1521 match self {
1522 Self::MATERIAL_INDICES_INVALID => {
1523 __serializer.serialize_field("MATERIAL_INDICES_INVALID", &0u64)
1524 }
1525 Self::MATERIAL_INDICES_INT8 => {
1526 __serializer.serialize_field("MATERIAL_INDICES_INT8", &1u64)
1527 }
1528 Self::MATERIAL_INDICES_INT16 => {
1529 __serializer.serialize_field("MATERIAL_INDICES_INT16", &2u64)
1530 }
1531 Self::MATERIAL_INDICES_MAX_ID => {
1532 __serializer.serialize_field("MATERIAL_INDICES_MAX_ID", &3u64)
1533 }
1534 }?;
1535 use num_traits::ToPrimitive as _;
1536 let num = self
1537 .to_i8()
1538 .ok_or(S::Error::custom("Failed enum MaterialIndexStridingType to_i8"))?;
1539 __serializer.serialize_bits(&num)?;
1540 __serializer.end()
1541 }
1542 }
1543};
1544const _: () = {
1545 use havok_serde as __serde;
1546 impl __serde::Serialize for SubpartType {
1547 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1548 where
1549 S: __serde::ser::Serializer,
1550 {
1551 let mut __serializer = __serializer.serialize_enum_flags()?;
1552 match self {
1553 Self::SUBPART_TRIANGLES => {
1554 __serializer.serialize_field("SUBPART_TRIANGLES", &0u64)
1555 }
1556 Self::SUBPART_SHAPE => {
1557 __serializer.serialize_field("SUBPART_SHAPE", &1u64)
1558 }
1559 }?;
1560 use num_traits::ToPrimitive as _;
1561 let num = self
1562 .to_i8()
1563 .ok_or(S::Error::custom("Failed enum SubpartType to_i8"))?;
1564 __serializer.serialize_bits(&num)?;
1565 __serializer.end()
1566 }
1567 }
1568};
1569#[doc(hidden)]
1570#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1571const _: () = {
1572 #[allow(unused_extern_crates, clippy::useless_attribute)]
1573 extern crate havok_serde as _serde;
1574 #[automatically_derived]
1575 impl<'de> _serde::Deserialize<'de> for IndexStridingType {
1576 fn deserialize<__D>(
1577 __deserializer: __D,
1578 ) -> _serde::__private::Result<Self, __D::Error>
1579 where
1580 __D: _serde::Deserializer<'de>,
1581 {
1582 #[allow(non_camel_case_types)]
1583 #[doc(hidden)]
1584 enum __Field {
1585 __field0,
1586 __field1,
1587 __field2,
1588 __field3,
1589 __field4,
1590 }
1591 #[doc(hidden)]
1592 struct __FieldVisitor;
1593 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1594 type Value = __Field;
1595 fn expecting(
1596 &self,
1597 __formatter: &mut _serde::__private::Formatter,
1598 ) -> _serde::__private::fmt::Result {
1599 _serde::__private::Formatter::write_str(
1600 __formatter,
1601 "variant identifier",
1602 )
1603 }
1604 fn visit_int8<__E>(
1605 self,
1606 __value: i8,
1607 ) -> _serde::__private::Result<Self::Value, __E>
1608 where
1609 __E: _serde::de::Error,
1610 {
1611 match __value {
1612 0i8 => _serde::__private::Ok(__Field::__field0),
1613 1i8 => _serde::__private::Ok(__Field::__field1),
1614 2i8 => _serde::__private::Ok(__Field::__field2),
1615 3i8 => _serde::__private::Ok(__Field::__field3),
1616 4i8 => _serde::__private::Ok(__Field::__field4),
1617 _ => {
1618 _serde::__private::Err(
1619 _serde::de::Error::invalid_value(
1620 _serde::de::Unexpected::Int8(__value),
1621 &"value(i8) of variant is one of 0, 1, 2, 3, 4",
1622 ),
1623 )
1624 }
1625 }
1626 }
1627 fn visit_stringptr<__E>(
1628 self,
1629 __value: StringPtr<'de>,
1630 ) -> _serde::__private::Result<Self::Value, __E>
1631 where
1632 __E: _serde::de::Error,
1633 {
1634 if let Some(__value) = __value.into_inner() {
1635 match __value.as_ref() {
1636 v if v == "0"
1637 || v.eq_ignore_ascii_case("INDICES_INVALID") => {
1638 _serde::__private::Ok(__Field::__field0)
1639 }
1640 v if v == "1" || v.eq_ignore_ascii_case("INDICES_INT8") => {
1641 _serde::__private::Ok(__Field::__field1)
1642 }
1643 v if v == "2" || v.eq_ignore_ascii_case("INDICES_INT16") => {
1644 _serde::__private::Ok(__Field::__field2)
1645 }
1646 v if v == "3" || v.eq_ignore_ascii_case("INDICES_INT32") => {
1647 _serde::__private::Ok(__Field::__field3)
1648 }
1649 v if v == "4" || v.eq_ignore_ascii_case("INDICES_MAX_ID") => {
1650 _serde::__private::Ok(__Field::__field4)
1651 }
1652 _ => {
1653 _serde::__private::Err(
1654 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1655 )
1656 }
1657 }
1658 } else {
1659 _serde::__private::Err(
1660 _serde::de::Error::unknown_variant("None", VARIANTS),
1661 )
1662 }
1663 }
1664 }
1665 impl<'de> _serde::Deserialize<'de> for __Field {
1666 #[inline]
1667 fn deserialize<__D>(
1668 __deserializer: __D,
1669 ) -> _serde::__private::Result<Self, __D::Error>
1670 where
1671 __D: _serde::Deserializer<'de>,
1672 {
1673 _serde::Deserializer::deserialize_identifier(
1674 __deserializer,
1675 _serde::de::ReadEnumSize::Int8,
1676 __FieldVisitor,
1677 )
1678 }
1679 }
1680 #[doc(hidden)]
1681 struct __Visitor<'de> {
1682 marker: _serde::__private::PhantomData<IndexStridingType>,
1683 lifetime: _serde::__private::PhantomData<&'de ()>,
1684 }
1685 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1686 type Value = IndexStridingType;
1687 fn expecting(
1688 &self,
1689 __formatter: &mut _serde::__private::Formatter,
1690 ) -> _serde::__private::fmt::Result {
1691 _serde::__private::Formatter::write_str(
1692 __formatter,
1693 "enum IndexStridingType",
1694 )
1695 }
1696 fn visit_enum<__A>(
1697 self,
1698 __data: __A,
1699 ) -> _serde::__private::Result<Self::Value, __A::Error>
1700 where
1701 __A: _serde::de::EnumAccess<'de>,
1702 {
1703 match _serde::de::EnumAccess::variant(__data)? {
1704 (__Field::__field0, __variant) => {
1705 _serde::de::VariantAccess::unit_variant(__variant)?;
1706 _serde::__private::Ok(IndexStridingType::INDICES_INVALID)
1707 }
1708 (__Field::__field1, __variant) => {
1709 _serde::de::VariantAccess::unit_variant(__variant)?;
1710 _serde::__private::Ok(IndexStridingType::INDICES_INT8)
1711 }
1712 (__Field::__field2, __variant) => {
1713 _serde::de::VariantAccess::unit_variant(__variant)?;
1714 _serde::__private::Ok(IndexStridingType::INDICES_INT16)
1715 }
1716 (__Field::__field3, __variant) => {
1717 _serde::de::VariantAccess::unit_variant(__variant)?;
1718 _serde::__private::Ok(IndexStridingType::INDICES_INT32)
1719 }
1720 (__Field::__field4, __variant) => {
1721 _serde::de::VariantAccess::unit_variant(__variant)?;
1722 _serde::__private::Ok(IndexStridingType::INDICES_MAX_ID)
1723 }
1724 }
1725 }
1726 }
1727 #[doc(hidden)]
1728 const VARIANTS: &'static [&'static str] = &[
1729 "INDICES_INVALID",
1730 "INDICES_INT8",
1731 "INDICES_INT16",
1732 "INDICES_INT32",
1733 "INDICES_MAX_ID",
1734 ];
1735 _serde::Deserializer::deserialize_enum(
1736 __deserializer,
1737 "IndexStridingType",
1738 VARIANTS,
1739 __Visitor {
1740 marker: _serde::__private::PhantomData::<IndexStridingType>,
1741 lifetime: _serde::__private::PhantomData,
1742 },
1743 )
1744 }
1745 }
1746};
1747#[doc(hidden)]
1748#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1749const _: () = {
1750 #[allow(unused_extern_crates, clippy::useless_attribute)]
1751 extern crate havok_serde as _serde;
1752 #[automatically_derived]
1753 impl<'de> _serde::Deserialize<'de> for MaterialIndexStridingType {
1754 fn deserialize<__D>(
1755 __deserializer: __D,
1756 ) -> _serde::__private::Result<Self, __D::Error>
1757 where
1758 __D: _serde::Deserializer<'de>,
1759 {
1760 #[allow(non_camel_case_types)]
1761 #[doc(hidden)]
1762 enum __Field {
1763 __field0,
1764 __field1,
1765 __field2,
1766 __field3,
1767 }
1768 #[doc(hidden)]
1769 struct __FieldVisitor;
1770 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1771 type Value = __Field;
1772 fn expecting(
1773 &self,
1774 __formatter: &mut _serde::__private::Formatter,
1775 ) -> _serde::__private::fmt::Result {
1776 _serde::__private::Formatter::write_str(
1777 __formatter,
1778 "variant identifier",
1779 )
1780 }
1781 fn visit_int8<__E>(
1782 self,
1783 __value: i8,
1784 ) -> _serde::__private::Result<Self::Value, __E>
1785 where
1786 __E: _serde::de::Error,
1787 {
1788 match __value {
1789 0i8 => _serde::__private::Ok(__Field::__field0),
1790 1i8 => _serde::__private::Ok(__Field::__field1),
1791 2i8 => _serde::__private::Ok(__Field::__field2),
1792 3i8 => _serde::__private::Ok(__Field::__field3),
1793 _ => {
1794 _serde::__private::Err(
1795 _serde::de::Error::invalid_value(
1796 _serde::de::Unexpected::Int8(__value),
1797 &"value(i8) of variant is one of 0, 1, 2, 3",
1798 ),
1799 )
1800 }
1801 }
1802 }
1803 fn visit_stringptr<__E>(
1804 self,
1805 __value: StringPtr<'de>,
1806 ) -> _serde::__private::Result<Self::Value, __E>
1807 where
1808 __E: _serde::de::Error,
1809 {
1810 if let Some(__value) = __value.into_inner() {
1811 match __value.as_ref() {
1812 v if v == "0"
1813 || v.eq_ignore_ascii_case("MATERIAL_INDICES_INVALID") => {
1814 _serde::__private::Ok(__Field::__field0)
1815 }
1816 v if v == "1"
1817 || v.eq_ignore_ascii_case("MATERIAL_INDICES_INT8") => {
1818 _serde::__private::Ok(__Field::__field1)
1819 }
1820 v if v == "2"
1821 || v.eq_ignore_ascii_case("MATERIAL_INDICES_INT16") => {
1822 _serde::__private::Ok(__Field::__field2)
1823 }
1824 v if v == "3"
1825 || v.eq_ignore_ascii_case("MATERIAL_INDICES_MAX_ID") => {
1826 _serde::__private::Ok(__Field::__field3)
1827 }
1828 _ => {
1829 _serde::__private::Err(
1830 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1831 )
1832 }
1833 }
1834 } else {
1835 _serde::__private::Err(
1836 _serde::de::Error::unknown_variant("None", VARIANTS),
1837 )
1838 }
1839 }
1840 }
1841 impl<'de> _serde::Deserialize<'de> for __Field {
1842 #[inline]
1843 fn deserialize<__D>(
1844 __deserializer: __D,
1845 ) -> _serde::__private::Result<Self, __D::Error>
1846 where
1847 __D: _serde::Deserializer<'de>,
1848 {
1849 _serde::Deserializer::deserialize_identifier(
1850 __deserializer,
1851 _serde::de::ReadEnumSize::Int8,
1852 __FieldVisitor,
1853 )
1854 }
1855 }
1856 #[doc(hidden)]
1857 struct __Visitor<'de> {
1858 marker: _serde::__private::PhantomData<MaterialIndexStridingType>,
1859 lifetime: _serde::__private::PhantomData<&'de ()>,
1860 }
1861 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1862 type Value = MaterialIndexStridingType;
1863 fn expecting(
1864 &self,
1865 __formatter: &mut _serde::__private::Formatter,
1866 ) -> _serde::__private::fmt::Result {
1867 _serde::__private::Formatter::write_str(
1868 __formatter,
1869 "enum MaterialIndexStridingType",
1870 )
1871 }
1872 fn visit_enum<__A>(
1873 self,
1874 __data: __A,
1875 ) -> _serde::__private::Result<Self::Value, __A::Error>
1876 where
1877 __A: _serde::de::EnumAccess<'de>,
1878 {
1879 match _serde::de::EnumAccess::variant(__data)? {
1880 (__Field::__field0, __variant) => {
1881 _serde::de::VariantAccess::unit_variant(__variant)?;
1882 _serde::__private::Ok(
1883 MaterialIndexStridingType::MATERIAL_INDICES_INVALID,
1884 )
1885 }
1886 (__Field::__field1, __variant) => {
1887 _serde::de::VariantAccess::unit_variant(__variant)?;
1888 _serde::__private::Ok(
1889 MaterialIndexStridingType::MATERIAL_INDICES_INT8,
1890 )
1891 }
1892 (__Field::__field2, __variant) => {
1893 _serde::de::VariantAccess::unit_variant(__variant)?;
1894 _serde::__private::Ok(
1895 MaterialIndexStridingType::MATERIAL_INDICES_INT16,
1896 )
1897 }
1898 (__Field::__field3, __variant) => {
1899 _serde::de::VariantAccess::unit_variant(__variant)?;
1900 _serde::__private::Ok(
1901 MaterialIndexStridingType::MATERIAL_INDICES_MAX_ID,
1902 )
1903 }
1904 }
1905 }
1906 }
1907 #[doc(hidden)]
1908 const VARIANTS: &'static [&'static str] = &[
1909 "MATERIAL_INDICES_INVALID",
1910 "MATERIAL_INDICES_INT8",
1911 "MATERIAL_INDICES_INT16",
1912 "MATERIAL_INDICES_MAX_ID",
1913 ];
1914 _serde::Deserializer::deserialize_enum(
1915 __deserializer,
1916 "MaterialIndexStridingType",
1917 VARIANTS,
1918 __Visitor {
1919 marker: _serde::__private::PhantomData::<MaterialIndexStridingType>,
1920 lifetime: _serde::__private::PhantomData,
1921 },
1922 )
1923 }
1924 }
1925};
1926#[doc(hidden)]
1927#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1928const _: () = {
1929 #[allow(unused_extern_crates, clippy::useless_attribute)]
1930 extern crate havok_serde as _serde;
1931 #[automatically_derived]
1932 impl<'de> _serde::Deserialize<'de> for SubpartType {
1933 fn deserialize<__D>(
1934 __deserializer: __D,
1935 ) -> _serde::__private::Result<Self, __D::Error>
1936 where
1937 __D: _serde::Deserializer<'de>,
1938 {
1939 #[allow(non_camel_case_types)]
1940 #[doc(hidden)]
1941 enum __Field {
1942 __field0,
1943 __field1,
1944 }
1945 #[doc(hidden)]
1946 struct __FieldVisitor;
1947 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1948 type Value = __Field;
1949 fn expecting(
1950 &self,
1951 __formatter: &mut _serde::__private::Formatter,
1952 ) -> _serde::__private::fmt::Result {
1953 _serde::__private::Formatter::write_str(
1954 __formatter,
1955 "variant identifier",
1956 )
1957 }
1958 fn visit_int8<__E>(
1959 self,
1960 __value: i8,
1961 ) -> _serde::__private::Result<Self::Value, __E>
1962 where
1963 __E: _serde::de::Error,
1964 {
1965 match __value {
1966 0i8 => _serde::__private::Ok(__Field::__field0),
1967 1i8 => _serde::__private::Ok(__Field::__field1),
1968 _ => {
1969 _serde::__private::Err(
1970 _serde::de::Error::invalid_value(
1971 _serde::de::Unexpected::Int8(__value),
1972 &"value(i8) of variant is one of 0, 1",
1973 ),
1974 )
1975 }
1976 }
1977 }
1978 fn visit_stringptr<__E>(
1979 self,
1980 __value: StringPtr<'de>,
1981 ) -> _serde::__private::Result<Self::Value, __E>
1982 where
1983 __E: _serde::de::Error,
1984 {
1985 if let Some(__value) = __value.into_inner() {
1986 match __value.as_ref() {
1987 v if v == "0"
1988 || v.eq_ignore_ascii_case("SUBPART_TRIANGLES") => {
1989 _serde::__private::Ok(__Field::__field0)
1990 }
1991 v if v == "1" || v.eq_ignore_ascii_case("SUBPART_SHAPE") => {
1992 _serde::__private::Ok(__Field::__field1)
1993 }
1994 _ => {
1995 _serde::__private::Err(
1996 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1997 )
1998 }
1999 }
2000 } else {
2001 _serde::__private::Err(
2002 _serde::de::Error::unknown_variant("None", VARIANTS),
2003 )
2004 }
2005 }
2006 }
2007 impl<'de> _serde::Deserialize<'de> for __Field {
2008 #[inline]
2009 fn deserialize<__D>(
2010 __deserializer: __D,
2011 ) -> _serde::__private::Result<Self, __D::Error>
2012 where
2013 __D: _serde::Deserializer<'de>,
2014 {
2015 _serde::Deserializer::deserialize_identifier(
2016 __deserializer,
2017 _serde::de::ReadEnumSize::Int8,
2018 __FieldVisitor,
2019 )
2020 }
2021 }
2022 #[doc(hidden)]
2023 struct __Visitor<'de> {
2024 marker: _serde::__private::PhantomData<SubpartType>,
2025 lifetime: _serde::__private::PhantomData<&'de ()>,
2026 }
2027 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
2028 type Value = SubpartType;
2029 fn expecting(
2030 &self,
2031 __formatter: &mut _serde::__private::Formatter,
2032 ) -> _serde::__private::fmt::Result {
2033 _serde::__private::Formatter::write_str(
2034 __formatter,
2035 "enum SubpartType",
2036 )
2037 }
2038 fn visit_enum<__A>(
2039 self,
2040 __data: __A,
2041 ) -> _serde::__private::Result<Self::Value, __A::Error>
2042 where
2043 __A: _serde::de::EnumAccess<'de>,
2044 {
2045 match _serde::de::EnumAccess::variant(__data)? {
2046 (__Field::__field0, __variant) => {
2047 _serde::de::VariantAccess::unit_variant(__variant)?;
2048 _serde::__private::Ok(SubpartType::SUBPART_TRIANGLES)
2049 }
2050 (__Field::__field1, __variant) => {
2051 _serde::de::VariantAccess::unit_variant(__variant)?;
2052 _serde::__private::Ok(SubpartType::SUBPART_SHAPE)
2053 }
2054 }
2055 }
2056 }
2057 #[doc(hidden)]
2058 const VARIANTS: &'static [&'static str] = &[
2059 "SUBPART_TRIANGLES",
2060 "SUBPART_SHAPE",
2061 ];
2062 _serde::Deserializer::deserialize_enum(
2063 __deserializer,
2064 "SubpartType",
2065 VARIANTS,
2066 __Visitor {
2067 marker: _serde::__private::PhantomData::<SubpartType>,
2068 lifetime: _serde::__private::PhantomData,
2069 },
2070 )
2071 }
2072 }
2073};