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 hkpCompressedMeshShape<'a> {
15 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[cfg_attr(feature = "json_schema", schemars(flatten))]
28 #[cfg_attr(feature = "serde", serde(flatten))]
29 pub parent: hkpShapeCollection,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "bitsPerIndex"))]
35 #[cfg_attr(feature = "serde", serde(rename = "bitsPerIndex"))]
36 pub m_bitsPerIndex: i32,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "bitsPerWIndex"))]
42 #[cfg_attr(feature = "serde", serde(rename = "bitsPerWIndex"))]
43 pub m_bitsPerWIndex: i32,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "wIndexMask"))]
49 #[cfg_attr(feature = "serde", serde(rename = "wIndexMask"))]
50 pub m_wIndexMask: i32,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "indexMask"))]
56 #[cfg_attr(feature = "serde", serde(rename = "indexMask"))]
57 pub m_indexMask: i32,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "radius"))]
63 #[cfg_attr(feature = "serde", serde(rename = "radius"))]
64 pub m_radius: f32,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "weldingType"))]
70 #[cfg_attr(feature = "serde", serde(rename = "weldingType"))]
71 pub m_weldingType: WeldingType,
72 #[cfg_attr(feature = "json_schema", schemars(rename = "materialType"))]
77 #[cfg_attr(feature = "serde", serde(rename = "materialType"))]
78 pub m_materialType: MaterialType,
79 #[cfg_attr(feature = "json_schema", schemars(rename = "materials"))]
84 #[cfg_attr(feature = "serde", serde(rename = "materials"))]
85 pub m_materials: Vec<u32>,
86 #[cfg_attr(feature = "json_schema", schemars(rename = "materials16"))]
91 #[cfg_attr(feature = "serde", serde(rename = "materials16"))]
92 pub m_materials16: Vec<u16>,
93 #[cfg_attr(feature = "json_schema", schemars(rename = "materials8"))]
98 #[cfg_attr(feature = "serde", serde(rename = "materials8"))]
99 pub m_materials8: Vec<u8>,
100 #[cfg_attr(feature = "json_schema", schemars(rename = "transforms"))]
105 #[cfg_attr(feature = "serde", serde(rename = "transforms"))]
106 pub m_transforms: Vec<QsTransform>,
107 #[cfg_attr(feature = "json_schema", schemars(rename = "bigVertices"))]
112 #[cfg_attr(feature = "serde", serde(rename = "bigVertices"))]
113 pub m_bigVertices: Vec<Vector4>,
114 #[cfg_attr(feature = "json_schema", schemars(rename = "bigTriangles"))]
119 #[cfg_attr(feature = "serde", serde(rename = "bigTriangles"))]
120 pub m_bigTriangles: Vec<hkpCompressedMeshShapeBigTriangle>,
121 #[cfg_attr(feature = "json_schema", schemars(rename = "chunks"))]
126 #[cfg_attr(feature = "serde", serde(rename = "chunks"))]
127 pub m_chunks: Vec<hkpCompressedMeshShapeChunk>,
128 #[cfg_attr(feature = "json_schema", schemars(rename = "convexPieces"))]
133 #[cfg_attr(feature = "serde", serde(rename = "convexPieces"))]
134 pub m_convexPieces: Vec<hkpCompressedMeshShapeConvexPiece>,
135 #[cfg_attr(feature = "json_schema", schemars(rename = "error"))]
140 #[cfg_attr(feature = "serde", serde(rename = "error"))]
141 pub m_error: f32,
142 #[cfg_attr(feature = "json_schema", schemars(rename = "bounds"))]
147 #[cfg_attr(feature = "serde", serde(rename = "bounds"))]
148 pub m_bounds: hkAabb,
149 #[cfg_attr(feature = "json_schema", schemars(rename = "defaultCollisionFilterInfo"))]
154 #[cfg_attr(feature = "serde", serde(rename = "defaultCollisionFilterInfo"))]
155 pub m_defaultCollisionFilterInfo: u32,
156 #[cfg_attr(feature = "json_schema", schemars(rename = "meshMaterials"))]
162 #[cfg_attr(feature = "serde", serde(rename = "meshMaterials"))]
163 pub m_meshMaterials: Pointer,
164 #[cfg_attr(feature = "json_schema", schemars(rename = "materialStriding"))]
169 #[cfg_attr(feature = "serde", serde(rename = "materialStriding"))]
170 pub m_materialStriding: u16,
171 #[cfg_attr(feature = "json_schema", schemars(rename = "numMaterials"))]
176 #[cfg_attr(feature = "serde", serde(rename = "numMaterials"))]
177 pub m_numMaterials: u16,
178 #[cfg_attr(feature = "serde", serde(borrow))]
183 #[cfg_attr(feature = "json_schema", schemars(rename = "namedMaterials"))]
184 #[cfg_attr(feature = "serde", serde(rename = "namedMaterials"))]
185 pub m_namedMaterials: Vec<hkpNamedMeshMaterial<'a>>,
186}
187const _: () = {
188 use havok_serde as _serde;
189 impl<'a> _serde::HavokClass for hkpCompressedMeshShape<'a> {
190 #[inline]
191 fn name(&self) -> &'static str {
192 "hkpCompressedMeshShape"
193 }
194 #[inline]
195 fn signature(&self) -> _serde::__private::Signature {
196 _serde::__private::Signature::new(0xa62d5e6e)
197 }
198 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
199 fn deps_indexes(&self) -> Vec<usize> {
200 let mut v = Vec::new();
201 v.extend(
202 self
203 .m_bigTriangles
204 .iter()
205 .flat_map(|class| class.deps_indexes())
206 .collect::<Vec<usize>>(),
207 );
208 v.extend(
209 self
210 .m_chunks
211 .iter()
212 .flat_map(|class| class.deps_indexes())
213 .collect::<Vec<usize>>(),
214 );
215 v.extend(
216 self
217 .m_convexPieces
218 .iter()
219 .flat_map(|class| class.deps_indexes())
220 .collect::<Vec<usize>>(),
221 );
222 v.extend(self.m_bounds.deps_indexes());
223 v.push(self.m_meshMaterials.get());
224 v.extend(
225 self
226 .m_namedMaterials
227 .iter()
228 .flat_map(|class| class.deps_indexes())
229 .collect::<Vec<usize>>(),
230 );
231 v
232 }
233 }
234 impl<'a> _serde::Serialize for hkpCompressedMeshShape<'a> {
235 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
236 where
237 S: _serde::ser::Serializer,
238 {
239 let class_meta = self
240 .__ptr
241 .map(|name| (name, _serde::__private::Signature::new(0xa62d5e6e)));
242 let mut serializer = __serializer
243 .serialize_struct(
244 "hkpCompressedMeshShape",
245 class_meta,
246 (224u64, 304u64),
247 )?;
248 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
249 serializer
250 .skip_field(
251 "memSizeAndFlags",
252 &self.parent.parent.parent.m_memSizeAndFlags,
253 )?;
254 serializer
255 .skip_field(
256 "referenceCount",
257 &self.parent.parent.parent.m_referenceCount,
258 )?;
259 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
260 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
261 serializer.skip_field("type", &self.parent.parent.m_type)?;
262 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
263 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
264 serializer.serialize_field("disableWelding", &self.parent.m_disableWelding)?;
265 serializer.serialize_field("collectionType", &self.parent.m_collectionType)?;
266 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 6usize].as_slice())?;
267 serializer.serialize_field("bitsPerIndex", &self.m_bitsPerIndex)?;
268 serializer.serialize_field("bitsPerWIndex", &self.m_bitsPerWIndex)?;
269 serializer.serialize_field("wIndexMask", &self.m_wIndexMask)?;
270 serializer.serialize_field("indexMask", &self.m_indexMask)?;
271 serializer.serialize_field("radius", &self.m_radius)?;
272 serializer.serialize_field("weldingType", &self.m_weldingType)?;
273 serializer.serialize_field("materialType", &self.m_materialType)?;
274 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
275 serializer
276 .serialize_array_field(
277 "materials",
278 &self.m_materials,
279 TypeSize::NonPtr,
280 )?;
281 serializer
282 .serialize_array_field(
283 "materials16",
284 &self.m_materials16,
285 TypeSize::NonPtr,
286 )?;
287 serializer
288 .serialize_array_field(
289 "materials8",
290 &self.m_materials8,
291 TypeSize::NonPtr,
292 )?;
293 serializer
294 .serialize_array_field(
295 "transforms",
296 &self.m_transforms,
297 TypeSize::NonPtr,
298 )?;
299 serializer
300 .serialize_array_field(
301 "bigVertices",
302 &self.m_bigVertices,
303 TypeSize::NonPtr,
304 )?;
305 serializer
306 .serialize_array_field(
307 "bigTriangles",
308 &self.m_bigTriangles,
309 TypeSize::Struct {
310 size_x86: 16u64,
311 size_x86_64: 16u64,
312 },
313 )?;
314 serializer
315 .serialize_array_field(
316 "chunks",
317 &self.m_chunks,
318 TypeSize::Struct {
319 size_x86: 80u64,
320 size_x86_64: 96u64,
321 },
322 )?;
323 serializer
324 .serialize_array_field(
325 "convexPieces",
326 &self.m_convexPieces,
327 TypeSize::Struct {
328 size_x86: 64u64,
329 size_x86_64: 80u64,
330 },
331 )?;
332 serializer.serialize_field("error", &self.m_error)?;
333 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 4usize].as_slice())?;
334 serializer.serialize_field("bounds", &self.m_bounds)?;
335 serializer
336 .serialize_field(
337 "defaultCollisionFilterInfo",
338 &self.m_defaultCollisionFilterInfo,
339 )?;
340 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
341 serializer.skip_field("meshMaterials", &self.m_meshMaterials)?;
342 serializer.serialize_field("materialStriding", &self.m_materialStriding)?;
343 serializer.serialize_field("numMaterials", &self.m_numMaterials)?;
344 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
345 serializer
346 .serialize_array_field(
347 "namedMaterials",
348 &self.m_namedMaterials,
349 TypeSize::Struct {
350 size_x86: 8u64,
351 size_x86_64: 16u64,
352 },
353 )?;
354 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 24usize].as_slice())?;
355 serializer.end()
356 }
357 }
358};
359#[doc(hidden)]
360#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
361const _: () = {
362 use havok_serde as _serde;
363 #[automatically_derived]
364 impl<'de> _serde::Deserialize<'de> for hkpCompressedMeshShape<'de> {
365 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
366 where
367 __D: _serde::Deserializer<'de>,
368 {
369 #[allow(non_camel_case_types)]
370 enum __Field {
371 m_userData,
372 m_disableWelding,
373 m_collectionType,
374 m_bitsPerIndex,
375 m_bitsPerWIndex,
376 m_wIndexMask,
377 m_indexMask,
378 m_radius,
379 m_weldingType,
380 m_materialType,
381 m_materials,
382 m_materials16,
383 m_materials8,
384 m_transforms,
385 m_bigVertices,
386 m_bigTriangles,
387 m_chunks,
388 m_convexPieces,
389 m_error,
390 m_bounds,
391 m_defaultCollisionFilterInfo,
392 m_materialStriding,
393 m_numMaterials,
394 m_namedMaterials,
395 __ignore,
396 }
397 struct __FieldVisitor;
398 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
399 type Value = __Field;
400 fn expecting(
401 &self,
402 __formatter: &mut core::fmt::Formatter,
403 ) -> core::fmt::Result {
404 core::fmt::Formatter::write_str(__formatter, "field identifier")
405 }
406 #[allow(clippy::match_single_binding)]
408 #[allow(clippy::reversed_empty_ranges)]
409 #[allow(clippy::single_match)]
410 fn visit_key<__E>(
411 self,
412 __value: &str,
413 ) -> core::result::Result<Self::Value, __E>
414 where
415 __E: _serde::de::Error,
416 {
417 match __value {
418 "userData" => Ok(__Field::m_userData),
419 "disableWelding" => Ok(__Field::m_disableWelding),
420 "collectionType" => Ok(__Field::m_collectionType),
421 "bitsPerIndex" => Ok(__Field::m_bitsPerIndex),
422 "bitsPerWIndex" => Ok(__Field::m_bitsPerWIndex),
423 "wIndexMask" => Ok(__Field::m_wIndexMask),
424 "indexMask" => Ok(__Field::m_indexMask),
425 "radius" => Ok(__Field::m_radius),
426 "weldingType" => Ok(__Field::m_weldingType),
427 "materialType" => Ok(__Field::m_materialType),
428 "materials" => Ok(__Field::m_materials),
429 "materials16" => Ok(__Field::m_materials16),
430 "materials8" => Ok(__Field::m_materials8),
431 "transforms" => Ok(__Field::m_transforms),
432 "bigVertices" => Ok(__Field::m_bigVertices),
433 "bigTriangles" => Ok(__Field::m_bigTriangles),
434 "chunks" => Ok(__Field::m_chunks),
435 "convexPieces" => Ok(__Field::m_convexPieces),
436 "error" => Ok(__Field::m_error),
437 "bounds" => Ok(__Field::m_bounds),
438 "defaultCollisionFilterInfo" => {
439 Ok(__Field::m_defaultCollisionFilterInfo)
440 }
441 "materialStriding" => Ok(__Field::m_materialStriding),
442 "numMaterials" => Ok(__Field::m_numMaterials),
443 "namedMaterials" => Ok(__Field::m_namedMaterials),
444 _ => Ok(__Field::__ignore),
445 }
446 }
447 }
448 impl<'de> _serde::Deserialize<'de> for __Field {
449 #[inline]
450 fn deserialize<__D>(
451 __deserializer: __D,
452 ) -> core::result::Result<Self, __D::Error>
453 where
454 __D: _serde::Deserializer<'de>,
455 {
456 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
457 }
458 }
459 struct __hkpCompressedMeshShapeVisitor<'de> {
460 marker: _serde::__private::PhantomData<hkpCompressedMeshShape<'de>>,
461 lifetime: _serde::__private::PhantomData<&'de ()>,
462 }
463 #[allow(clippy::match_single_binding)]
464 #[allow(clippy::reversed_empty_ranges)]
465 #[allow(clippy::single_match)]
466 impl<'de> _serde::de::Visitor<'de> for __hkpCompressedMeshShapeVisitor<'de> {
467 type Value = hkpCompressedMeshShape<'de>;
468 fn expecting(
469 &self,
470 __formatter: &mut core::fmt::Formatter,
471 ) -> core::fmt::Result {
472 core::fmt::Formatter::write_str(
473 __formatter,
474 "struct hkpCompressedMeshShape",
475 )
476 }
477 fn visit_struct_for_bytes<__A>(
478 self,
479 mut __map: __A,
480 ) -> _serde::__private::Result<Self::Value, __A::Error>
481 where
482 __A: _serde::de::MapAccess<'de>,
483 {
484 let __ptr = __A::class_ptr(&mut __map);
485 let parent = __A::parent_value(&mut __map)?;
486 let mut m_bitsPerIndex: _serde::__private::Option<i32> = _serde::__private::None;
487 let mut m_bitsPerWIndex: _serde::__private::Option<i32> = _serde::__private::None;
488 let mut m_wIndexMask: _serde::__private::Option<i32> = _serde::__private::None;
489 let mut m_indexMask: _serde::__private::Option<i32> = _serde::__private::None;
490 let mut m_radius: _serde::__private::Option<f32> = _serde::__private::None;
491 let mut m_weldingType: _serde::__private::Option<WeldingType> = _serde::__private::None;
492 let mut m_materialType: _serde::__private::Option<MaterialType> = _serde::__private::None;
493 let mut m_materials: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
494 let mut m_materials16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
495 let mut m_materials8: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
496 let mut m_transforms: _serde::__private::Option<Vec<QsTransform>> = _serde::__private::None;
497 let mut m_bigVertices: _serde::__private::Option<Vec<Vector4>> = _serde::__private::None;
498 let mut m_bigTriangles: _serde::__private::Option<
499 Vec<hkpCompressedMeshShapeBigTriangle>,
500 > = _serde::__private::None;
501 let mut m_chunks: _serde::__private::Option<
502 Vec<hkpCompressedMeshShapeChunk>,
503 > = _serde::__private::None;
504 let mut m_convexPieces: _serde::__private::Option<
505 Vec<hkpCompressedMeshShapeConvexPiece>,
506 > = _serde::__private::None;
507 let mut m_error: _serde::__private::Option<f32> = _serde::__private::None;
508 let mut m_bounds: _serde::__private::Option<hkAabb> = _serde::__private::None;
509 let mut m_defaultCollisionFilterInfo: _serde::__private::Option<
510 u32,
511 > = _serde::__private::None;
512 let mut m_meshMaterials: _serde::__private::Option<Pointer> = _serde::__private::None;
513 let mut m_materialStriding: _serde::__private::Option<u16> = _serde::__private::None;
514 let mut m_numMaterials: _serde::__private::Option<u16> = _serde::__private::None;
515 let mut m_namedMaterials: _serde::__private::Option<
516 Vec<hkpNamedMeshMaterial<'de>>,
517 > = _serde::__private::None;
518 for i in 0..22usize {
519 match i {
520 0usize => {
521 if _serde::__private::Option::is_some(&m_bitsPerIndex) {
522 return _serde::__private::Err(
523 <__A::Error as _serde::de::Error>::duplicate_field(
524 "bitsPerIndex",
525 ),
526 );
527 }
528 m_bitsPerIndex = _serde::__private::Some(
529 match __A::next_value::<i32>(&mut __map) {
530 _serde::__private::Ok(__val) => __val,
531 _serde::__private::Err(__err) => {
532 return _serde::__private::Err(__err);
533 }
534 },
535 );
536 }
537 1usize => {
538 if _serde::__private::Option::is_some(&m_bitsPerWIndex) {
539 return _serde::__private::Err(
540 <__A::Error as _serde::de::Error>::duplicate_field(
541 "bitsPerWIndex",
542 ),
543 );
544 }
545 m_bitsPerWIndex = _serde::__private::Some(
546 match __A::next_value::<i32>(&mut __map) {
547 _serde::__private::Ok(__val) => __val,
548 _serde::__private::Err(__err) => {
549 return _serde::__private::Err(__err);
550 }
551 },
552 );
553 }
554 2usize => {
555 if _serde::__private::Option::is_some(&m_wIndexMask) {
556 return _serde::__private::Err(
557 <__A::Error as _serde::de::Error>::duplicate_field(
558 "wIndexMask",
559 ),
560 );
561 }
562 m_wIndexMask = _serde::__private::Some(
563 match __A::next_value::<i32>(&mut __map) {
564 _serde::__private::Ok(__val) => __val,
565 _serde::__private::Err(__err) => {
566 return _serde::__private::Err(__err);
567 }
568 },
569 );
570 }
571 3usize => {
572 if _serde::__private::Option::is_some(&m_indexMask) {
573 return _serde::__private::Err(
574 <__A::Error as _serde::de::Error>::duplicate_field(
575 "indexMask",
576 ),
577 );
578 }
579 m_indexMask = _serde::__private::Some(
580 match __A::next_value::<i32>(&mut __map) {
581 _serde::__private::Ok(__val) => __val,
582 _serde::__private::Err(__err) => {
583 return _serde::__private::Err(__err);
584 }
585 },
586 );
587 }
588 4usize => {
589 if _serde::__private::Option::is_some(&m_radius) {
590 return _serde::__private::Err(
591 <__A::Error as _serde::de::Error>::duplicate_field("radius"),
592 );
593 }
594 m_radius = _serde::__private::Some(
595 match __A::next_value::<f32>(&mut __map) {
596 _serde::__private::Ok(__val) => __val,
597 _serde::__private::Err(__err) => {
598 return _serde::__private::Err(__err);
599 }
600 },
601 );
602 }
603 5usize => {
604 if _serde::__private::Option::is_some(&m_weldingType) {
605 return _serde::__private::Err(
606 <__A::Error as _serde::de::Error>::duplicate_field(
607 "weldingType",
608 ),
609 );
610 }
611 m_weldingType = _serde::__private::Some(
612 match __A::next_value::<WeldingType>(&mut __map) {
613 _serde::__private::Ok(__val) => __val,
614 _serde::__private::Err(__err) => {
615 return _serde::__private::Err(__err);
616 }
617 },
618 );
619 }
620 6usize => {
621 if _serde::__private::Option::is_some(&m_materialType) {
622 return _serde::__private::Err(
623 <__A::Error as _serde::de::Error>::duplicate_field(
624 "materialType",
625 ),
626 );
627 }
628 m_materialType = _serde::__private::Some(
629 match __A::next_value::<MaterialType>(&mut __map) {
630 _serde::__private::Ok(__val) => __val,
631 _serde::__private::Err(__err) => {
632 return _serde::__private::Err(__err);
633 }
634 },
635 );
636 }
637 7usize => {
638 if _serde::__private::Option::is_some(&m_materials) {
639 return _serde::__private::Err(
640 <__A::Error as _serde::de::Error>::duplicate_field(
641 "materials",
642 ),
643 );
644 }
645 __A::pad(&mut __map, 2usize, 2usize)?;
646 m_materials = _serde::__private::Some(
647 match __A::next_value::<Vec<u32>>(&mut __map) {
648 _serde::__private::Ok(__val) => __val,
649 _serde::__private::Err(__err) => {
650 return _serde::__private::Err(__err);
651 }
652 },
653 );
654 }
655 8usize => {
656 if _serde::__private::Option::is_some(&m_materials16) {
657 return _serde::__private::Err(
658 <__A::Error as _serde::de::Error>::duplicate_field(
659 "materials16",
660 ),
661 );
662 }
663 m_materials16 = _serde::__private::Some(
664 match __A::next_value::<Vec<u16>>(&mut __map) {
665 _serde::__private::Ok(__val) => __val,
666 _serde::__private::Err(__err) => {
667 return _serde::__private::Err(__err);
668 }
669 },
670 );
671 }
672 9usize => {
673 if _serde::__private::Option::is_some(&m_materials8) {
674 return _serde::__private::Err(
675 <__A::Error as _serde::de::Error>::duplicate_field(
676 "materials8",
677 ),
678 );
679 }
680 m_materials8 = _serde::__private::Some(
681 match __A::next_value::<Vec<u8>>(&mut __map) {
682 _serde::__private::Ok(__val) => __val,
683 _serde::__private::Err(__err) => {
684 return _serde::__private::Err(__err);
685 }
686 },
687 );
688 }
689 10usize => {
690 if _serde::__private::Option::is_some(&m_transforms) {
691 return _serde::__private::Err(
692 <__A::Error as _serde::de::Error>::duplicate_field(
693 "transforms",
694 ),
695 );
696 }
697 m_transforms = _serde::__private::Some(
698 match __A::next_value::<Vec<QsTransform>>(&mut __map) {
699 _serde::__private::Ok(__val) => __val,
700 _serde::__private::Err(__err) => {
701 return _serde::__private::Err(__err);
702 }
703 },
704 );
705 }
706 11usize => {
707 if _serde::__private::Option::is_some(&m_bigVertices) {
708 return _serde::__private::Err(
709 <__A::Error as _serde::de::Error>::duplicate_field(
710 "bigVertices",
711 ),
712 );
713 }
714 m_bigVertices = _serde::__private::Some(
715 match __A::next_value::<Vec<Vector4>>(&mut __map) {
716 _serde::__private::Ok(__val) => __val,
717 _serde::__private::Err(__err) => {
718 return _serde::__private::Err(__err);
719 }
720 },
721 );
722 }
723 12usize => {
724 if _serde::__private::Option::is_some(&m_bigTriangles) {
725 return _serde::__private::Err(
726 <__A::Error as _serde::de::Error>::duplicate_field(
727 "bigTriangles",
728 ),
729 );
730 }
731 m_bigTriangles = _serde::__private::Some(
732 match __A::next_value::<
733 Vec<hkpCompressedMeshShapeBigTriangle>,
734 >(&mut __map) {
735 _serde::__private::Ok(__val) => __val,
736 _serde::__private::Err(__err) => {
737 return _serde::__private::Err(__err);
738 }
739 },
740 );
741 }
742 13usize => {
743 if _serde::__private::Option::is_some(&m_chunks) {
744 return _serde::__private::Err(
745 <__A::Error as _serde::de::Error>::duplicate_field("chunks"),
746 );
747 }
748 m_chunks = _serde::__private::Some(
749 match __A::next_value::<
750 Vec<hkpCompressedMeshShapeChunk>,
751 >(&mut __map) {
752 _serde::__private::Ok(__val) => __val,
753 _serde::__private::Err(__err) => {
754 return _serde::__private::Err(__err);
755 }
756 },
757 );
758 }
759 14usize => {
760 if _serde::__private::Option::is_some(&m_convexPieces) {
761 return _serde::__private::Err(
762 <__A::Error as _serde::de::Error>::duplicate_field(
763 "convexPieces",
764 ),
765 );
766 }
767 m_convexPieces = _serde::__private::Some(
768 match __A::next_value::<
769 Vec<hkpCompressedMeshShapeConvexPiece>,
770 >(&mut __map) {
771 _serde::__private::Ok(__val) => __val,
772 _serde::__private::Err(__err) => {
773 return _serde::__private::Err(__err);
774 }
775 },
776 );
777 }
778 15usize => {
779 if _serde::__private::Option::is_some(&m_error) {
780 return _serde::__private::Err(
781 <__A::Error as _serde::de::Error>::duplicate_field("error"),
782 );
783 }
784 m_error = _serde::__private::Some(
785 match __A::next_value::<f32>(&mut __map) {
786 _serde::__private::Ok(__val) => __val,
787 _serde::__private::Err(__err) => {
788 return _serde::__private::Err(__err);
789 }
790 },
791 );
792 }
793 16usize => {
794 if _serde::__private::Option::is_some(&m_bounds) {
795 return _serde::__private::Err(
796 <__A::Error as _serde::de::Error>::duplicate_field("bounds"),
797 );
798 }
799 __A::pad(&mut __map, 12usize, 4usize)?;
800 m_bounds = _serde::__private::Some(
801 match __A::next_value::<hkAabb>(&mut __map) {
802 _serde::__private::Ok(__val) => __val,
803 _serde::__private::Err(__err) => {
804 return _serde::__private::Err(__err);
805 }
806 },
807 );
808 }
809 17usize => {
810 if _serde::__private::Option::is_some(
811 &m_defaultCollisionFilterInfo,
812 ) {
813 return _serde::__private::Err(
814 <__A::Error as _serde::de::Error>::duplicate_field(
815 "defaultCollisionFilterInfo",
816 ),
817 );
818 }
819 m_defaultCollisionFilterInfo = _serde::__private::Some(
820 match __A::next_value::<u32>(&mut __map) {
821 _serde::__private::Ok(__val) => __val,
822 _serde::__private::Err(__err) => {
823 return _serde::__private::Err(__err);
824 }
825 },
826 );
827 }
828 18usize => {
829 if _serde::__private::Option::is_some(&m_meshMaterials) {
830 return _serde::__private::Err(
831 <__A::Error as _serde::de::Error>::duplicate_field(
832 "meshMaterials",
833 ),
834 );
835 }
836 __A::pad(&mut __map, 0usize, 4usize)?;
837 m_meshMaterials = _serde::__private::Some(
838 match __A::next_value::<Pointer>(&mut __map) {
839 _serde::__private::Ok(__val) => __val,
840 _serde::__private::Err(__err) => {
841 return _serde::__private::Err(__err);
842 }
843 },
844 );
845 }
846 19usize => {
847 if _serde::__private::Option::is_some(&m_materialStriding) {
848 return _serde::__private::Err(
849 <__A::Error as _serde::de::Error>::duplicate_field(
850 "materialStriding",
851 ),
852 );
853 }
854 m_materialStriding = _serde::__private::Some(
855 match __A::next_value::<u16>(&mut __map) {
856 _serde::__private::Ok(__val) => __val,
857 _serde::__private::Err(__err) => {
858 return _serde::__private::Err(__err);
859 }
860 },
861 );
862 }
863 20usize => {
864 if _serde::__private::Option::is_some(&m_numMaterials) {
865 return _serde::__private::Err(
866 <__A::Error as _serde::de::Error>::duplicate_field(
867 "numMaterials",
868 ),
869 );
870 }
871 m_numMaterials = _serde::__private::Some(
872 match __A::next_value::<u16>(&mut __map) {
873 _serde::__private::Ok(__val) => __val,
874 _serde::__private::Err(__err) => {
875 return _serde::__private::Err(__err);
876 }
877 },
878 );
879 }
880 21usize => {
881 if _serde::__private::Option::is_some(&m_namedMaterials) {
882 return _serde::__private::Err(
883 <__A::Error as _serde::de::Error>::duplicate_field(
884 "namedMaterials",
885 ),
886 );
887 }
888 __A::pad(&mut __map, 0usize, 4usize)?;
889 m_namedMaterials = _serde::__private::Some(
890 match __A::next_value::<
891 Vec<hkpNamedMeshMaterial<'de>>,
892 >(&mut __map) {
893 _serde::__private::Ok(__val) => __val,
894 _serde::__private::Err(__err) => {
895 return _serde::__private::Err(__err);
896 }
897 },
898 );
899 }
900 _ => {}
901 }
902 }
903 __A::pad(&mut __map, 8usize, 24usize)?;
904 let m_bitsPerIndex = match m_bitsPerIndex {
905 _serde::__private::Some(__field) => __field,
906 _serde::__private::None => {
907 return _serde::__private::Err(
908 <__A::Error as _serde::de::Error>::missing_field(
909 "bitsPerIndex",
910 ),
911 );
912 }
913 };
914 let m_bitsPerWIndex = match m_bitsPerWIndex {
915 _serde::__private::Some(__field) => __field,
916 _serde::__private::None => {
917 return _serde::__private::Err(
918 <__A::Error as _serde::de::Error>::missing_field(
919 "bitsPerWIndex",
920 ),
921 );
922 }
923 };
924 let m_wIndexMask = match m_wIndexMask {
925 _serde::__private::Some(__field) => __field,
926 _serde::__private::None => {
927 return _serde::__private::Err(
928 <__A::Error as _serde::de::Error>::missing_field(
929 "wIndexMask",
930 ),
931 );
932 }
933 };
934 let m_indexMask = match m_indexMask {
935 _serde::__private::Some(__field) => __field,
936 _serde::__private::None => {
937 return _serde::__private::Err(
938 <__A::Error as _serde::de::Error>::missing_field(
939 "indexMask",
940 ),
941 );
942 }
943 };
944 let m_radius = match m_radius {
945 _serde::__private::Some(__field) => __field,
946 _serde::__private::None => {
947 return _serde::__private::Err(
948 <__A::Error as _serde::de::Error>::missing_field("radius"),
949 );
950 }
951 };
952 let m_weldingType = match m_weldingType {
953 _serde::__private::Some(__field) => __field,
954 _serde::__private::None => {
955 return _serde::__private::Err(
956 <__A::Error as _serde::de::Error>::missing_field(
957 "weldingType",
958 ),
959 );
960 }
961 };
962 let m_materialType = match m_materialType {
963 _serde::__private::Some(__field) => __field,
964 _serde::__private::None => {
965 return _serde::__private::Err(
966 <__A::Error as _serde::de::Error>::missing_field(
967 "materialType",
968 ),
969 );
970 }
971 };
972 let m_materials = match m_materials {
973 _serde::__private::Some(__field) => __field,
974 _serde::__private::None => {
975 return _serde::__private::Err(
976 <__A::Error as _serde::de::Error>::missing_field(
977 "materials",
978 ),
979 );
980 }
981 };
982 let m_materials16 = match m_materials16 {
983 _serde::__private::Some(__field) => __field,
984 _serde::__private::None => {
985 return _serde::__private::Err(
986 <__A::Error as _serde::de::Error>::missing_field(
987 "materials16",
988 ),
989 );
990 }
991 };
992 let m_materials8 = match m_materials8 {
993 _serde::__private::Some(__field) => __field,
994 _serde::__private::None => {
995 return _serde::__private::Err(
996 <__A::Error as _serde::de::Error>::missing_field(
997 "materials8",
998 ),
999 );
1000 }
1001 };
1002 let m_transforms = match m_transforms {
1003 _serde::__private::Some(__field) => __field,
1004 _serde::__private::None => {
1005 return _serde::__private::Err(
1006 <__A::Error as _serde::de::Error>::missing_field(
1007 "transforms",
1008 ),
1009 );
1010 }
1011 };
1012 let m_bigVertices = match m_bigVertices {
1013 _serde::__private::Some(__field) => __field,
1014 _serde::__private::None => {
1015 return _serde::__private::Err(
1016 <__A::Error as _serde::de::Error>::missing_field(
1017 "bigVertices",
1018 ),
1019 );
1020 }
1021 };
1022 let m_bigTriangles = match m_bigTriangles {
1023 _serde::__private::Some(__field) => __field,
1024 _serde::__private::None => {
1025 return _serde::__private::Err(
1026 <__A::Error as _serde::de::Error>::missing_field(
1027 "bigTriangles",
1028 ),
1029 );
1030 }
1031 };
1032 let m_chunks = match m_chunks {
1033 _serde::__private::Some(__field) => __field,
1034 _serde::__private::None => {
1035 return _serde::__private::Err(
1036 <__A::Error as _serde::de::Error>::missing_field("chunks"),
1037 );
1038 }
1039 };
1040 let m_convexPieces = match m_convexPieces {
1041 _serde::__private::Some(__field) => __field,
1042 _serde::__private::None => {
1043 return _serde::__private::Err(
1044 <__A::Error as _serde::de::Error>::missing_field(
1045 "convexPieces",
1046 ),
1047 );
1048 }
1049 };
1050 let m_error = match m_error {
1051 _serde::__private::Some(__field) => __field,
1052 _serde::__private::None => {
1053 return _serde::__private::Err(
1054 <__A::Error as _serde::de::Error>::missing_field("error"),
1055 );
1056 }
1057 };
1058 let m_bounds = match m_bounds {
1059 _serde::__private::Some(__field) => __field,
1060 _serde::__private::None => {
1061 return _serde::__private::Err(
1062 <__A::Error as _serde::de::Error>::missing_field("bounds"),
1063 );
1064 }
1065 };
1066 let m_defaultCollisionFilterInfo = match m_defaultCollisionFilterInfo {
1067 _serde::__private::Some(__field) => __field,
1068 _serde::__private::None => {
1069 return _serde::__private::Err(
1070 <__A::Error as _serde::de::Error>::missing_field(
1071 "defaultCollisionFilterInfo",
1072 ),
1073 );
1074 }
1075 };
1076 let m_meshMaterials = match m_meshMaterials {
1077 _serde::__private::Some(__field) => __field,
1078 _serde::__private::None => {
1079 return _serde::__private::Err(
1080 <__A::Error as _serde::de::Error>::missing_field(
1081 "meshMaterials",
1082 ),
1083 );
1084 }
1085 };
1086 let m_materialStriding = match m_materialStriding {
1087 _serde::__private::Some(__field) => __field,
1088 _serde::__private::None => {
1089 return _serde::__private::Err(
1090 <__A::Error as _serde::de::Error>::missing_field(
1091 "materialStriding",
1092 ),
1093 );
1094 }
1095 };
1096 let m_numMaterials = match m_numMaterials {
1097 _serde::__private::Some(__field) => __field,
1098 _serde::__private::None => {
1099 return _serde::__private::Err(
1100 <__A::Error as _serde::de::Error>::missing_field(
1101 "numMaterials",
1102 ),
1103 );
1104 }
1105 };
1106 let m_namedMaterials = match m_namedMaterials {
1107 _serde::__private::Some(__field) => __field,
1108 _serde::__private::None => {
1109 return _serde::__private::Err(
1110 <__A::Error as _serde::de::Error>::missing_field(
1111 "namedMaterials",
1112 ),
1113 );
1114 }
1115 };
1116 _serde::__private::Ok(hkpCompressedMeshShape {
1117 __ptr,
1118 parent,
1119 m_bitsPerIndex,
1120 m_bitsPerWIndex,
1121 m_wIndexMask,
1122 m_indexMask,
1123 m_radius,
1124 m_weldingType,
1125 m_materialType,
1126 m_materials,
1127 m_materials16,
1128 m_materials8,
1129 m_transforms,
1130 m_bigVertices,
1131 m_bigTriangles,
1132 m_chunks,
1133 m_convexPieces,
1134 m_error,
1135 m_bounds,
1136 m_defaultCollisionFilterInfo,
1137 m_meshMaterials,
1138 m_materialStriding,
1139 m_numMaterials,
1140 m_namedMaterials,
1141 })
1142 }
1143 #[allow(clippy::manual_unwrap_or_default)]
1144 fn visit_struct<__A>(
1145 self,
1146 mut __map: __A,
1147 ) -> _serde::__private::Result<Self::Value, __A::Error>
1148 where
1149 __A: _serde::de::MapAccess<'de>,
1150 {
1151 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1152 let mut m_disableWelding: _serde::__private::Option<bool> = _serde::__private::None;
1153 let mut m_collectionType: _serde::__private::Option<
1154 CollectionType,
1155 > = _serde::__private::None;
1156 let mut m_bitsPerIndex: _serde::__private::Option<i32> = _serde::__private::None;
1157 let mut m_bitsPerWIndex: _serde::__private::Option<i32> = _serde::__private::None;
1158 let mut m_wIndexMask: _serde::__private::Option<i32> = _serde::__private::None;
1159 let mut m_indexMask: _serde::__private::Option<i32> = _serde::__private::None;
1160 let mut m_radius: _serde::__private::Option<f32> = _serde::__private::None;
1161 let mut m_weldingType: _serde::__private::Option<WeldingType> = _serde::__private::None;
1162 let mut m_materialType: _serde::__private::Option<MaterialType> = _serde::__private::None;
1163 let mut m_materials: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
1164 let mut m_materials16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
1165 let mut m_materials8: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
1166 let mut m_transforms: _serde::__private::Option<Vec<QsTransform>> = _serde::__private::None;
1167 let mut m_bigVertices: _serde::__private::Option<Vec<Vector4>> = _serde::__private::None;
1168 let mut m_bigTriangles: _serde::__private::Option<
1169 Vec<hkpCompressedMeshShapeBigTriangle>,
1170 > = _serde::__private::None;
1171 let mut m_chunks: _serde::__private::Option<
1172 Vec<hkpCompressedMeshShapeChunk>,
1173 > = _serde::__private::None;
1174 let mut m_convexPieces: _serde::__private::Option<
1175 Vec<hkpCompressedMeshShapeConvexPiece>,
1176 > = _serde::__private::None;
1177 let mut m_error: _serde::__private::Option<f32> = _serde::__private::None;
1178 let mut m_bounds: _serde::__private::Option<hkAabb> = _serde::__private::None;
1179 let mut m_defaultCollisionFilterInfo: _serde::__private::Option<
1180 u32,
1181 > = _serde::__private::None;
1182 let mut m_materialStriding: _serde::__private::Option<u16> = _serde::__private::None;
1183 let mut m_numMaterials: _serde::__private::Option<u16> = _serde::__private::None;
1184 let mut m_namedMaterials: _serde::__private::Option<
1185 Vec<hkpNamedMeshMaterial<'de>>,
1186 > = _serde::__private::None;
1187 while let _serde::__private::Some(__key) = {
1188 __A::next_key::<__Field>(&mut __map)?
1189 } {
1190 match __key {
1191 __Field::m_userData => {
1192 #[cfg(
1193 any(feature = "strict", feature = "ignore_duplicates")
1194 )]
1195 if _serde::__private::Option::is_some(&m_userData) {
1196 #[cfg(feature = "ignore_duplicates")]
1197 {
1198 __A::skip_value(&mut __map)?;
1199 continue;
1200 }
1201 #[cfg(feature = "strict")]
1202 return _serde::__private::Err(
1203 <__A::Error as _serde::de::Error>::duplicate_field(
1204 "userData",
1205 ),
1206 );
1207 }
1208 m_userData = _serde::__private::Some(
1209 match __A::next_value::<Ulong>(&mut __map) {
1210 _serde::__private::Ok(__val) => __val,
1211 _serde::__private::Err(__err) => {
1212 return _serde::__private::Err(__err);
1213 }
1214 },
1215 );
1216 }
1217 __Field::m_disableWelding => {
1218 #[cfg(
1219 any(feature = "strict", feature = "ignore_duplicates")
1220 )]
1221 if _serde::__private::Option::is_some(&m_disableWelding) {
1222 #[cfg(feature = "ignore_duplicates")]
1223 {
1224 __A::skip_value(&mut __map)?;
1225 continue;
1226 }
1227 #[cfg(feature = "strict")]
1228 return _serde::__private::Err(
1229 <__A::Error as _serde::de::Error>::duplicate_field(
1230 "disableWelding",
1231 ),
1232 );
1233 }
1234 m_disableWelding = _serde::__private::Some(
1235 match __A::next_value::<bool>(&mut __map) {
1236 _serde::__private::Ok(__val) => __val,
1237 _serde::__private::Err(__err) => {
1238 return _serde::__private::Err(__err);
1239 }
1240 },
1241 );
1242 }
1243 __Field::m_collectionType => {
1244 #[cfg(
1245 any(feature = "strict", feature = "ignore_duplicates")
1246 )]
1247 if _serde::__private::Option::is_some(&m_collectionType) {
1248 #[cfg(feature = "ignore_duplicates")]
1249 {
1250 __A::skip_value(&mut __map)?;
1251 continue;
1252 }
1253 #[cfg(feature = "strict")]
1254 return _serde::__private::Err(
1255 <__A::Error as _serde::de::Error>::duplicate_field(
1256 "collectionType",
1257 ),
1258 );
1259 }
1260 m_collectionType = _serde::__private::Some(
1261 match __A::next_value::<CollectionType>(&mut __map) {
1262 _serde::__private::Ok(__val) => __val,
1263 _serde::__private::Err(__err) => {
1264 return _serde::__private::Err(__err);
1265 }
1266 },
1267 );
1268 }
1269 __Field::m_bitsPerIndex => {
1270 #[cfg(
1271 any(feature = "strict", feature = "ignore_duplicates")
1272 )]
1273 if _serde::__private::Option::is_some(&m_bitsPerIndex) {
1274 #[cfg(feature = "ignore_duplicates")]
1275 {
1276 __A::skip_value(&mut __map)?;
1277 continue;
1278 }
1279 #[cfg(feature = "strict")]
1280 return _serde::__private::Err(
1281 <__A::Error as _serde::de::Error>::duplicate_field(
1282 "bitsPerIndex",
1283 ),
1284 );
1285 }
1286 m_bitsPerIndex = _serde::__private::Some(
1287 match __A::next_value::<i32>(&mut __map) {
1288 _serde::__private::Ok(__val) => __val,
1289 _serde::__private::Err(__err) => {
1290 return _serde::__private::Err(__err);
1291 }
1292 },
1293 );
1294 }
1295 __Field::m_bitsPerWIndex => {
1296 #[cfg(
1297 any(feature = "strict", feature = "ignore_duplicates")
1298 )]
1299 if _serde::__private::Option::is_some(&m_bitsPerWIndex) {
1300 #[cfg(feature = "ignore_duplicates")]
1301 {
1302 __A::skip_value(&mut __map)?;
1303 continue;
1304 }
1305 #[cfg(feature = "strict")]
1306 return _serde::__private::Err(
1307 <__A::Error as _serde::de::Error>::duplicate_field(
1308 "bitsPerWIndex",
1309 ),
1310 );
1311 }
1312 m_bitsPerWIndex = _serde::__private::Some(
1313 match __A::next_value::<i32>(&mut __map) {
1314 _serde::__private::Ok(__val) => __val,
1315 _serde::__private::Err(__err) => {
1316 return _serde::__private::Err(__err);
1317 }
1318 },
1319 );
1320 }
1321 __Field::m_wIndexMask => {
1322 #[cfg(
1323 any(feature = "strict", feature = "ignore_duplicates")
1324 )]
1325 if _serde::__private::Option::is_some(&m_wIndexMask) {
1326 #[cfg(feature = "ignore_duplicates")]
1327 {
1328 __A::skip_value(&mut __map)?;
1329 continue;
1330 }
1331 #[cfg(feature = "strict")]
1332 return _serde::__private::Err(
1333 <__A::Error as _serde::de::Error>::duplicate_field(
1334 "wIndexMask",
1335 ),
1336 );
1337 }
1338 m_wIndexMask = _serde::__private::Some(
1339 match __A::next_value::<i32>(&mut __map) {
1340 _serde::__private::Ok(__val) => __val,
1341 _serde::__private::Err(__err) => {
1342 return _serde::__private::Err(__err);
1343 }
1344 },
1345 );
1346 }
1347 __Field::m_indexMask => {
1348 #[cfg(
1349 any(feature = "strict", feature = "ignore_duplicates")
1350 )]
1351 if _serde::__private::Option::is_some(&m_indexMask) {
1352 #[cfg(feature = "ignore_duplicates")]
1353 {
1354 __A::skip_value(&mut __map)?;
1355 continue;
1356 }
1357 #[cfg(feature = "strict")]
1358 return _serde::__private::Err(
1359 <__A::Error as _serde::de::Error>::duplicate_field(
1360 "indexMask",
1361 ),
1362 );
1363 }
1364 m_indexMask = _serde::__private::Some(
1365 match __A::next_value::<i32>(&mut __map) {
1366 _serde::__private::Ok(__val) => __val,
1367 _serde::__private::Err(__err) => {
1368 return _serde::__private::Err(__err);
1369 }
1370 },
1371 );
1372 }
1373 __Field::m_radius => {
1374 #[cfg(
1375 any(feature = "strict", feature = "ignore_duplicates")
1376 )]
1377 if _serde::__private::Option::is_some(&m_radius) {
1378 #[cfg(feature = "ignore_duplicates")]
1379 {
1380 __A::skip_value(&mut __map)?;
1381 continue;
1382 }
1383 #[cfg(feature = "strict")]
1384 return _serde::__private::Err(
1385 <__A::Error as _serde::de::Error>::duplicate_field("radius"),
1386 );
1387 }
1388 m_radius = _serde::__private::Some(
1389 match __A::next_value::<f32>(&mut __map) {
1390 _serde::__private::Ok(__val) => __val,
1391 _serde::__private::Err(__err) => {
1392 return _serde::__private::Err(__err);
1393 }
1394 },
1395 );
1396 }
1397 __Field::m_weldingType => {
1398 #[cfg(
1399 any(feature = "strict", feature = "ignore_duplicates")
1400 )]
1401 if _serde::__private::Option::is_some(&m_weldingType) {
1402 #[cfg(feature = "ignore_duplicates")]
1403 {
1404 __A::skip_value(&mut __map)?;
1405 continue;
1406 }
1407 #[cfg(feature = "strict")]
1408 return _serde::__private::Err(
1409 <__A::Error as _serde::de::Error>::duplicate_field(
1410 "weldingType",
1411 ),
1412 );
1413 }
1414 m_weldingType = _serde::__private::Some(
1415 match __A::next_value::<WeldingType>(&mut __map) {
1416 _serde::__private::Ok(__val) => __val,
1417 _serde::__private::Err(__err) => {
1418 return _serde::__private::Err(__err);
1419 }
1420 },
1421 );
1422 }
1423 __Field::m_materialType => {
1424 #[cfg(
1425 any(feature = "strict", feature = "ignore_duplicates")
1426 )]
1427 if _serde::__private::Option::is_some(&m_materialType) {
1428 #[cfg(feature = "ignore_duplicates")]
1429 {
1430 __A::skip_value(&mut __map)?;
1431 continue;
1432 }
1433 #[cfg(feature = "strict")]
1434 return _serde::__private::Err(
1435 <__A::Error as _serde::de::Error>::duplicate_field(
1436 "materialType",
1437 ),
1438 );
1439 }
1440 m_materialType = _serde::__private::Some(
1441 match __A::next_value::<MaterialType>(&mut __map) {
1442 _serde::__private::Ok(__val) => __val,
1443 _serde::__private::Err(__err) => {
1444 return _serde::__private::Err(__err);
1445 }
1446 },
1447 );
1448 }
1449 __Field::m_materials => {
1450 #[cfg(
1451 any(feature = "strict", feature = "ignore_duplicates")
1452 )]
1453 if _serde::__private::Option::is_some(&m_materials) {
1454 #[cfg(feature = "ignore_duplicates")]
1455 {
1456 __A::skip_value(&mut __map)?;
1457 continue;
1458 }
1459 #[cfg(feature = "strict")]
1460 return _serde::__private::Err(
1461 <__A::Error as _serde::de::Error>::duplicate_field(
1462 "materials",
1463 ),
1464 );
1465 }
1466 m_materials = _serde::__private::Some(
1467 match __A::next_value::<Vec<u32>>(&mut __map) {
1468 _serde::__private::Ok(__val) => __val,
1469 _serde::__private::Err(__err) => {
1470 return _serde::__private::Err(__err);
1471 }
1472 },
1473 );
1474 }
1475 __Field::m_materials16 => {
1476 #[cfg(
1477 any(feature = "strict", feature = "ignore_duplicates")
1478 )]
1479 if _serde::__private::Option::is_some(&m_materials16) {
1480 #[cfg(feature = "ignore_duplicates")]
1481 {
1482 __A::skip_value(&mut __map)?;
1483 continue;
1484 }
1485 #[cfg(feature = "strict")]
1486 return _serde::__private::Err(
1487 <__A::Error as _serde::de::Error>::duplicate_field(
1488 "materials16",
1489 ),
1490 );
1491 }
1492 m_materials16 = _serde::__private::Some(
1493 match __A::next_value::<Vec<u16>>(&mut __map) {
1494 _serde::__private::Ok(__val) => __val,
1495 _serde::__private::Err(__err) => {
1496 return _serde::__private::Err(__err);
1497 }
1498 },
1499 );
1500 }
1501 __Field::m_materials8 => {
1502 #[cfg(
1503 any(feature = "strict", feature = "ignore_duplicates")
1504 )]
1505 if _serde::__private::Option::is_some(&m_materials8) {
1506 #[cfg(feature = "ignore_duplicates")]
1507 {
1508 __A::skip_value(&mut __map)?;
1509 continue;
1510 }
1511 #[cfg(feature = "strict")]
1512 return _serde::__private::Err(
1513 <__A::Error as _serde::de::Error>::duplicate_field(
1514 "materials8",
1515 ),
1516 );
1517 }
1518 m_materials8 = _serde::__private::Some(
1519 match __A::next_value::<Vec<u8>>(&mut __map) {
1520 _serde::__private::Ok(__val) => __val,
1521 _serde::__private::Err(__err) => {
1522 return _serde::__private::Err(__err);
1523 }
1524 },
1525 );
1526 }
1527 __Field::m_transforms => {
1528 #[cfg(
1529 any(feature = "strict", feature = "ignore_duplicates")
1530 )]
1531 if _serde::__private::Option::is_some(&m_transforms) {
1532 #[cfg(feature = "ignore_duplicates")]
1533 {
1534 __A::skip_value(&mut __map)?;
1535 continue;
1536 }
1537 #[cfg(feature = "strict")]
1538 return _serde::__private::Err(
1539 <__A::Error as _serde::de::Error>::duplicate_field(
1540 "transforms",
1541 ),
1542 );
1543 }
1544 m_transforms = _serde::__private::Some(
1545 match __A::next_value::<Vec<QsTransform>>(&mut __map) {
1546 _serde::__private::Ok(__val) => __val,
1547 _serde::__private::Err(__err) => {
1548 return _serde::__private::Err(__err);
1549 }
1550 },
1551 );
1552 }
1553 __Field::m_bigVertices => {
1554 #[cfg(
1555 any(feature = "strict", feature = "ignore_duplicates")
1556 )]
1557 if _serde::__private::Option::is_some(&m_bigVertices) {
1558 #[cfg(feature = "ignore_duplicates")]
1559 {
1560 __A::skip_value(&mut __map)?;
1561 continue;
1562 }
1563 #[cfg(feature = "strict")]
1564 return _serde::__private::Err(
1565 <__A::Error as _serde::de::Error>::duplicate_field(
1566 "bigVertices",
1567 ),
1568 );
1569 }
1570 m_bigVertices = _serde::__private::Some(
1571 match __A::next_value::<Vec<Vector4>>(&mut __map) {
1572 _serde::__private::Ok(__val) => __val,
1573 _serde::__private::Err(__err) => {
1574 return _serde::__private::Err(__err);
1575 }
1576 },
1577 );
1578 }
1579 __Field::m_bigTriangles => {
1580 #[cfg(
1581 any(feature = "strict", feature = "ignore_duplicates")
1582 )]
1583 if _serde::__private::Option::is_some(&m_bigTriangles) {
1584 #[cfg(feature = "ignore_duplicates")]
1585 {
1586 __A::skip_value(&mut __map)?;
1587 continue;
1588 }
1589 #[cfg(feature = "strict")]
1590 return _serde::__private::Err(
1591 <__A::Error as _serde::de::Error>::duplicate_field(
1592 "bigTriangles",
1593 ),
1594 );
1595 }
1596 m_bigTriangles = _serde::__private::Some(
1597 match __A::next_value::<
1598 Vec<hkpCompressedMeshShapeBigTriangle>,
1599 >(&mut __map) {
1600 _serde::__private::Ok(__val) => __val,
1601 _serde::__private::Err(__err) => {
1602 return _serde::__private::Err(__err);
1603 }
1604 },
1605 );
1606 }
1607 __Field::m_chunks => {
1608 #[cfg(
1609 any(feature = "strict", feature = "ignore_duplicates")
1610 )]
1611 if _serde::__private::Option::is_some(&m_chunks) {
1612 #[cfg(feature = "ignore_duplicates")]
1613 {
1614 __A::skip_value(&mut __map)?;
1615 continue;
1616 }
1617 #[cfg(feature = "strict")]
1618 return _serde::__private::Err(
1619 <__A::Error as _serde::de::Error>::duplicate_field("chunks"),
1620 );
1621 }
1622 m_chunks = _serde::__private::Some(
1623 match __A::next_value::<
1624 Vec<hkpCompressedMeshShapeChunk>,
1625 >(&mut __map) {
1626 _serde::__private::Ok(__val) => __val,
1627 _serde::__private::Err(__err) => {
1628 return _serde::__private::Err(__err);
1629 }
1630 },
1631 );
1632 }
1633 __Field::m_convexPieces => {
1634 #[cfg(
1635 any(feature = "strict", feature = "ignore_duplicates")
1636 )]
1637 if _serde::__private::Option::is_some(&m_convexPieces) {
1638 #[cfg(feature = "ignore_duplicates")]
1639 {
1640 __A::skip_value(&mut __map)?;
1641 continue;
1642 }
1643 #[cfg(feature = "strict")]
1644 return _serde::__private::Err(
1645 <__A::Error as _serde::de::Error>::duplicate_field(
1646 "convexPieces",
1647 ),
1648 );
1649 }
1650 m_convexPieces = _serde::__private::Some(
1651 match __A::next_value::<
1652 Vec<hkpCompressedMeshShapeConvexPiece>,
1653 >(&mut __map) {
1654 _serde::__private::Ok(__val) => __val,
1655 _serde::__private::Err(__err) => {
1656 return _serde::__private::Err(__err);
1657 }
1658 },
1659 );
1660 }
1661 __Field::m_error => {
1662 #[cfg(
1663 any(feature = "strict", feature = "ignore_duplicates")
1664 )]
1665 if _serde::__private::Option::is_some(&m_error) {
1666 #[cfg(feature = "ignore_duplicates")]
1667 {
1668 __A::skip_value(&mut __map)?;
1669 continue;
1670 }
1671 #[cfg(feature = "strict")]
1672 return _serde::__private::Err(
1673 <__A::Error as _serde::de::Error>::duplicate_field("error"),
1674 );
1675 }
1676 m_error = _serde::__private::Some(
1677 match __A::next_value::<f32>(&mut __map) {
1678 _serde::__private::Ok(__val) => __val,
1679 _serde::__private::Err(__err) => {
1680 return _serde::__private::Err(__err);
1681 }
1682 },
1683 );
1684 }
1685 __Field::m_bounds => {
1686 #[cfg(
1687 any(feature = "strict", feature = "ignore_duplicates")
1688 )]
1689 if _serde::__private::Option::is_some(&m_bounds) {
1690 #[cfg(feature = "ignore_duplicates")]
1691 {
1692 __A::skip_value(&mut __map)?;
1693 continue;
1694 }
1695 #[cfg(feature = "strict")]
1696 return _serde::__private::Err(
1697 <__A::Error as _serde::de::Error>::duplicate_field("bounds"),
1698 );
1699 }
1700 m_bounds = _serde::__private::Some(
1701 match __A::next_value::<hkAabb>(&mut __map) {
1702 _serde::__private::Ok(__val) => __val,
1703 _serde::__private::Err(__err) => {
1704 return _serde::__private::Err(__err);
1705 }
1706 },
1707 );
1708 }
1709 __Field::m_defaultCollisionFilterInfo => {
1710 #[cfg(
1711 any(feature = "strict", feature = "ignore_duplicates")
1712 )]
1713 if _serde::__private::Option::is_some(
1714 &m_defaultCollisionFilterInfo,
1715 ) {
1716 #[cfg(feature = "ignore_duplicates")]
1717 {
1718 __A::skip_value(&mut __map)?;
1719 continue;
1720 }
1721 #[cfg(feature = "strict")]
1722 return _serde::__private::Err(
1723 <__A::Error as _serde::de::Error>::duplicate_field(
1724 "defaultCollisionFilterInfo",
1725 ),
1726 );
1727 }
1728 m_defaultCollisionFilterInfo = _serde::__private::Some(
1729 match __A::next_value::<u32>(&mut __map) {
1730 _serde::__private::Ok(__val) => __val,
1731 _serde::__private::Err(__err) => {
1732 return _serde::__private::Err(__err);
1733 }
1734 },
1735 );
1736 }
1737 __Field::m_materialStriding => {
1738 #[cfg(
1739 any(feature = "strict", feature = "ignore_duplicates")
1740 )]
1741 if _serde::__private::Option::is_some(&m_materialStriding) {
1742 #[cfg(feature = "ignore_duplicates")]
1743 {
1744 __A::skip_value(&mut __map)?;
1745 continue;
1746 }
1747 #[cfg(feature = "strict")]
1748 return _serde::__private::Err(
1749 <__A::Error as _serde::de::Error>::duplicate_field(
1750 "materialStriding",
1751 ),
1752 );
1753 }
1754 m_materialStriding = _serde::__private::Some(
1755 match __A::next_value::<u16>(&mut __map) {
1756 _serde::__private::Ok(__val) => __val,
1757 _serde::__private::Err(__err) => {
1758 return _serde::__private::Err(__err);
1759 }
1760 },
1761 );
1762 }
1763 __Field::m_numMaterials => {
1764 #[cfg(
1765 any(feature = "strict", feature = "ignore_duplicates")
1766 )]
1767 if _serde::__private::Option::is_some(&m_numMaterials) {
1768 #[cfg(feature = "ignore_duplicates")]
1769 {
1770 __A::skip_value(&mut __map)?;
1771 continue;
1772 }
1773 #[cfg(feature = "strict")]
1774 return _serde::__private::Err(
1775 <__A::Error as _serde::de::Error>::duplicate_field(
1776 "numMaterials",
1777 ),
1778 );
1779 }
1780 m_numMaterials = _serde::__private::Some(
1781 match __A::next_value::<u16>(&mut __map) {
1782 _serde::__private::Ok(__val) => __val,
1783 _serde::__private::Err(__err) => {
1784 return _serde::__private::Err(__err);
1785 }
1786 },
1787 );
1788 }
1789 __Field::m_namedMaterials => {
1790 #[cfg(
1791 any(feature = "strict", feature = "ignore_duplicates")
1792 )]
1793 if _serde::__private::Option::is_some(&m_namedMaterials) {
1794 #[cfg(feature = "ignore_duplicates")]
1795 {
1796 __A::skip_value(&mut __map)?;
1797 continue;
1798 }
1799 #[cfg(feature = "strict")]
1800 return _serde::__private::Err(
1801 <__A::Error as _serde::de::Error>::duplicate_field(
1802 "namedMaterials",
1803 ),
1804 );
1805 }
1806 m_namedMaterials = _serde::__private::Some(
1807 match __A::next_value::<
1808 Vec<hkpNamedMeshMaterial<'de>>,
1809 >(&mut __map) {
1810 _serde::__private::Ok(__val) => __val,
1811 _serde::__private::Err(__err) => {
1812 return _serde::__private::Err(__err);
1813 }
1814 },
1815 );
1816 }
1817 _ => __A::skip_value(&mut __map)?,
1818 }
1819 }
1820 let m_userData = match m_userData {
1821 _serde::__private::Some(__field) => __field,
1822 _serde::__private::None => {
1823 #[cfg(feature = "strict")]
1824 return _serde::__private::Err(
1825 <__A::Error as _serde::de::Error>::missing_field("userData"),
1826 );
1827 #[cfg(not(feature = "strict"))] Default::default()
1828 }
1829 };
1830 let m_disableWelding = match m_disableWelding {
1831 _serde::__private::Some(__field) => __field,
1832 _serde::__private::None => {
1833 #[cfg(feature = "strict")]
1834 return _serde::__private::Err(
1835 <__A::Error as _serde::de::Error>::missing_field(
1836 "disableWelding",
1837 ),
1838 );
1839 #[cfg(not(feature = "strict"))] Default::default()
1840 }
1841 };
1842 let m_collectionType = match m_collectionType {
1843 _serde::__private::Some(__field) => __field,
1844 _serde::__private::None => {
1845 #[cfg(feature = "strict")]
1846 return _serde::__private::Err(
1847 <__A::Error as _serde::de::Error>::missing_field(
1848 "collectionType",
1849 ),
1850 );
1851 #[cfg(not(feature = "strict"))] Default::default()
1852 }
1853 };
1854 let m_bitsPerIndex = match m_bitsPerIndex {
1855 _serde::__private::Some(__field) => __field,
1856 _serde::__private::None => {
1857 #[cfg(feature = "strict")]
1858 return _serde::__private::Err(
1859 <__A::Error as _serde::de::Error>::missing_field(
1860 "bitsPerIndex",
1861 ),
1862 );
1863 #[cfg(not(feature = "strict"))] Default::default()
1864 }
1865 };
1866 let m_bitsPerWIndex = match m_bitsPerWIndex {
1867 _serde::__private::Some(__field) => __field,
1868 _serde::__private::None => {
1869 #[cfg(feature = "strict")]
1870 return _serde::__private::Err(
1871 <__A::Error as _serde::de::Error>::missing_field(
1872 "bitsPerWIndex",
1873 ),
1874 );
1875 #[cfg(not(feature = "strict"))] Default::default()
1876 }
1877 };
1878 let m_wIndexMask = match m_wIndexMask {
1879 _serde::__private::Some(__field) => __field,
1880 _serde::__private::None => {
1881 #[cfg(feature = "strict")]
1882 return _serde::__private::Err(
1883 <__A::Error as _serde::de::Error>::missing_field(
1884 "wIndexMask",
1885 ),
1886 );
1887 #[cfg(not(feature = "strict"))] Default::default()
1888 }
1889 };
1890 let m_indexMask = match m_indexMask {
1891 _serde::__private::Some(__field) => __field,
1892 _serde::__private::None => {
1893 #[cfg(feature = "strict")]
1894 return _serde::__private::Err(
1895 <__A::Error as _serde::de::Error>::missing_field(
1896 "indexMask",
1897 ),
1898 );
1899 #[cfg(not(feature = "strict"))] Default::default()
1900 }
1901 };
1902 let m_radius = match m_radius {
1903 _serde::__private::Some(__field) => __field,
1904 _serde::__private::None => {
1905 #[cfg(feature = "strict")]
1906 return _serde::__private::Err(
1907 <__A::Error as _serde::de::Error>::missing_field("radius"),
1908 );
1909 #[cfg(not(feature = "strict"))] Default::default()
1910 }
1911 };
1912 let m_weldingType = match m_weldingType {
1913 _serde::__private::Some(__field) => __field,
1914 _serde::__private::None => {
1915 #[cfg(feature = "strict")]
1916 return _serde::__private::Err(
1917 <__A::Error as _serde::de::Error>::missing_field(
1918 "weldingType",
1919 ),
1920 );
1921 #[cfg(not(feature = "strict"))] Default::default()
1922 }
1923 };
1924 let m_materialType = match m_materialType {
1925 _serde::__private::Some(__field) => __field,
1926 _serde::__private::None => {
1927 #[cfg(feature = "strict")]
1928 return _serde::__private::Err(
1929 <__A::Error as _serde::de::Error>::missing_field(
1930 "materialType",
1931 ),
1932 );
1933 #[cfg(not(feature = "strict"))] Default::default()
1934 }
1935 };
1936 let m_materials = match m_materials {
1937 _serde::__private::Some(__field) => __field,
1938 _serde::__private::None => {
1939 #[cfg(feature = "strict")]
1940 return _serde::__private::Err(
1941 <__A::Error as _serde::de::Error>::missing_field(
1942 "materials",
1943 ),
1944 );
1945 #[cfg(not(feature = "strict"))] Default::default()
1946 }
1947 };
1948 let m_materials16 = match m_materials16 {
1949 _serde::__private::Some(__field) => __field,
1950 _serde::__private::None => {
1951 #[cfg(feature = "strict")]
1952 return _serde::__private::Err(
1953 <__A::Error as _serde::de::Error>::missing_field(
1954 "materials16",
1955 ),
1956 );
1957 #[cfg(not(feature = "strict"))] Default::default()
1958 }
1959 };
1960 let m_materials8 = match m_materials8 {
1961 _serde::__private::Some(__field) => __field,
1962 _serde::__private::None => {
1963 #[cfg(feature = "strict")]
1964 return _serde::__private::Err(
1965 <__A::Error as _serde::de::Error>::missing_field(
1966 "materials8",
1967 ),
1968 );
1969 #[cfg(not(feature = "strict"))] Default::default()
1970 }
1971 };
1972 let m_transforms = match m_transforms {
1973 _serde::__private::Some(__field) => __field,
1974 _serde::__private::None => {
1975 #[cfg(feature = "strict")]
1976 return _serde::__private::Err(
1977 <__A::Error as _serde::de::Error>::missing_field(
1978 "transforms",
1979 ),
1980 );
1981 #[cfg(not(feature = "strict"))] Default::default()
1982 }
1983 };
1984 let m_bigVertices = match m_bigVertices {
1985 _serde::__private::Some(__field) => __field,
1986 _serde::__private::None => {
1987 #[cfg(feature = "strict")]
1988 return _serde::__private::Err(
1989 <__A::Error as _serde::de::Error>::missing_field(
1990 "bigVertices",
1991 ),
1992 );
1993 #[cfg(not(feature = "strict"))] Default::default()
1994 }
1995 };
1996 let m_bigTriangles = match m_bigTriangles {
1997 _serde::__private::Some(__field) => __field,
1998 _serde::__private::None => {
1999 #[cfg(feature = "strict")]
2000 return _serde::__private::Err(
2001 <__A::Error as _serde::de::Error>::missing_field(
2002 "bigTriangles",
2003 ),
2004 );
2005 #[cfg(not(feature = "strict"))] Default::default()
2006 }
2007 };
2008 let m_chunks = match m_chunks {
2009 _serde::__private::Some(__field) => __field,
2010 _serde::__private::None => {
2011 #[cfg(feature = "strict")]
2012 return _serde::__private::Err(
2013 <__A::Error as _serde::de::Error>::missing_field("chunks"),
2014 );
2015 #[cfg(not(feature = "strict"))] Default::default()
2016 }
2017 };
2018 let m_convexPieces = match m_convexPieces {
2019 _serde::__private::Some(__field) => __field,
2020 _serde::__private::None => {
2021 #[cfg(feature = "strict")]
2022 return _serde::__private::Err(
2023 <__A::Error as _serde::de::Error>::missing_field(
2024 "convexPieces",
2025 ),
2026 );
2027 #[cfg(not(feature = "strict"))] Default::default()
2028 }
2029 };
2030 let m_error = match m_error {
2031 _serde::__private::Some(__field) => __field,
2032 _serde::__private::None => {
2033 #[cfg(feature = "strict")]
2034 return _serde::__private::Err(
2035 <__A::Error as _serde::de::Error>::missing_field("error"),
2036 );
2037 #[cfg(not(feature = "strict"))] Default::default()
2038 }
2039 };
2040 let m_bounds = match m_bounds {
2041 _serde::__private::Some(__field) => __field,
2042 _serde::__private::None => {
2043 #[cfg(feature = "strict")]
2044 return _serde::__private::Err(
2045 <__A::Error as _serde::de::Error>::missing_field("bounds"),
2046 );
2047 #[cfg(not(feature = "strict"))] Default::default()
2048 }
2049 };
2050 let m_defaultCollisionFilterInfo = match m_defaultCollisionFilterInfo {
2051 _serde::__private::Some(__field) => __field,
2052 _serde::__private::None => {
2053 #[cfg(feature = "strict")]
2054 return _serde::__private::Err(
2055 <__A::Error as _serde::de::Error>::missing_field(
2056 "defaultCollisionFilterInfo",
2057 ),
2058 );
2059 #[cfg(not(feature = "strict"))] Default::default()
2060 }
2061 };
2062 let m_materialStriding = match m_materialStriding {
2063 _serde::__private::Some(__field) => __field,
2064 _serde::__private::None => {
2065 #[cfg(feature = "strict")]
2066 return _serde::__private::Err(
2067 <__A::Error as _serde::de::Error>::missing_field(
2068 "materialStriding",
2069 ),
2070 );
2071 #[cfg(not(feature = "strict"))] Default::default()
2072 }
2073 };
2074 let m_numMaterials = match m_numMaterials {
2075 _serde::__private::Some(__field) => __field,
2076 _serde::__private::None => {
2077 #[cfg(feature = "strict")]
2078 return _serde::__private::Err(
2079 <__A::Error as _serde::de::Error>::missing_field(
2080 "numMaterials",
2081 ),
2082 );
2083 #[cfg(not(feature = "strict"))] Default::default()
2084 }
2085 };
2086 let m_namedMaterials = match m_namedMaterials {
2087 _serde::__private::Some(__field) => __field,
2088 _serde::__private::None => {
2089 #[cfg(feature = "strict")]
2090 return _serde::__private::Err(
2091 <__A::Error as _serde::de::Error>::missing_field(
2092 "namedMaterials",
2093 ),
2094 );
2095 #[cfg(not(feature = "strict"))] Default::default()
2096 }
2097 };
2098 let __ptr = None;
2099 let parent = hkBaseObject { __ptr };
2100 let parent = hkReferencedObject {
2101 __ptr,
2102 parent,
2103 ..Default::default()
2104 };
2105 let parent = hkpShape {
2106 __ptr,
2107 parent,
2108 m_userData,
2109 ..Default::default()
2110 };
2111 let parent = hkpShapeCollection {
2112 __ptr,
2113 parent,
2114 m_disableWelding,
2115 m_collectionType,
2116 };
2117 let __ptr = __A::class_ptr(&mut __map);
2118 _serde::__private::Ok(hkpCompressedMeshShape {
2119 __ptr,
2120 parent,
2121 m_bitsPerIndex,
2122 m_bitsPerWIndex,
2123 m_wIndexMask,
2124 m_indexMask,
2125 m_radius,
2126 m_weldingType,
2127 m_materialType,
2128 m_materials,
2129 m_materials16,
2130 m_materials8,
2131 m_transforms,
2132 m_bigVertices,
2133 m_bigTriangles,
2134 m_chunks,
2135 m_convexPieces,
2136 m_error,
2137 m_bounds,
2138 m_defaultCollisionFilterInfo,
2139 m_materialStriding,
2140 m_numMaterials,
2141 m_namedMaterials,
2142 ..Default::default()
2143 })
2144 }
2145 }
2146 const FIELDS: &[&str] = &[
2147 "bitsPerIndex",
2148 "bitsPerWIndex",
2149 "wIndexMask",
2150 "indexMask",
2151 "radius",
2152 "weldingType",
2153 "materialType",
2154 "materials",
2155 "materials16",
2156 "materials8",
2157 "transforms",
2158 "bigVertices",
2159 "bigTriangles",
2160 "chunks",
2161 "convexPieces",
2162 "error",
2163 "bounds",
2164 "defaultCollisionFilterInfo",
2165 "meshMaterials",
2166 "materialStriding",
2167 "numMaterials",
2168 "namedMaterials",
2169 ];
2170 _serde::Deserializer::deserialize_struct(
2171 deserializer,
2172 "hkpCompressedMeshShape",
2173 FIELDS,
2174 __hkpCompressedMeshShapeVisitor {
2175 marker: _serde::__private::PhantomData::<hkpCompressedMeshShape>,
2176 lifetime: _serde::__private::PhantomData,
2177 },
2178 )
2179 }
2180 }
2181};
2182#[allow(non_upper_case_globals, non_snake_case)]
2185#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
2186#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2187#[derive(
2188 Debug,
2189 Clone,
2190 Default,
2191 PartialEq,
2192 Eq,
2193 PartialOrd,
2194 Ord,
2195 num_derive::ToPrimitive,
2196 num_derive::FromPrimitive,
2197)]
2198pub enum MaterialType {
2199 #[default]
2200 MATERIAL_NONE = 0isize,
2201 MATERIAL_SINGLE_VALUE_PER_CHUNK = 1isize,
2202 MATERIAL_ONE_BYTE_PER_TRIANGLE = 2isize,
2203 MATERIAL_TWO_BYTES_PER_TRIANGLE = 3isize,
2204 MATERIAL_FOUR_BYTES_PER_TRIANGLE = 4isize,
2205}
2206const _: () = {
2207 use havok_serde as __serde;
2208 impl __serde::Serialize for MaterialType {
2209 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
2210 where
2211 S: __serde::ser::Serializer,
2212 {
2213 let mut __serializer = __serializer.serialize_enum_flags()?;
2214 match self {
2215 Self::MATERIAL_NONE => {
2216 __serializer.serialize_field("MATERIAL_NONE", &0u64)
2217 }
2218 Self::MATERIAL_SINGLE_VALUE_PER_CHUNK => {
2219 __serializer
2220 .serialize_field("MATERIAL_SINGLE_VALUE_PER_CHUNK", &1u64)
2221 }
2222 Self::MATERIAL_ONE_BYTE_PER_TRIANGLE => {
2223 __serializer.serialize_field("MATERIAL_ONE_BYTE_PER_TRIANGLE", &2u64)
2224 }
2225 Self::MATERIAL_TWO_BYTES_PER_TRIANGLE => {
2226 __serializer
2227 .serialize_field("MATERIAL_TWO_BYTES_PER_TRIANGLE", &3u64)
2228 }
2229 Self::MATERIAL_FOUR_BYTES_PER_TRIANGLE => {
2230 __serializer
2231 .serialize_field("MATERIAL_FOUR_BYTES_PER_TRIANGLE", &4u64)
2232 }
2233 }?;
2234 use num_traits::ToPrimitive as _;
2235 let num = self
2236 .to_u8()
2237 .ok_or(S::Error::custom("Failed enum MaterialType to_u8"))?;
2238 __serializer.serialize_bits(&num)?;
2239 __serializer.end()
2240 }
2241 }
2242};
2243#[doc(hidden)]
2244#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
2245const _: () = {
2246 #[allow(unused_extern_crates, clippy::useless_attribute)]
2247 extern crate havok_serde as _serde;
2248 #[automatically_derived]
2249 impl<'de> _serde::Deserialize<'de> for MaterialType {
2250 fn deserialize<__D>(
2251 __deserializer: __D,
2252 ) -> _serde::__private::Result<Self, __D::Error>
2253 where
2254 __D: _serde::Deserializer<'de>,
2255 {
2256 #[allow(non_camel_case_types)]
2257 #[doc(hidden)]
2258 enum __Field {
2259 __field0,
2260 __field1,
2261 __field2,
2262 __field3,
2263 __field4,
2264 }
2265 #[doc(hidden)]
2266 struct __FieldVisitor;
2267 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
2268 type Value = __Field;
2269 fn expecting(
2270 &self,
2271 __formatter: &mut _serde::__private::Formatter,
2272 ) -> _serde::__private::fmt::Result {
2273 _serde::__private::Formatter::write_str(
2274 __formatter,
2275 "variant identifier",
2276 )
2277 }
2278 fn visit_uint8<__E>(
2279 self,
2280 __value: u8,
2281 ) -> _serde::__private::Result<Self::Value, __E>
2282 where
2283 __E: _serde::de::Error,
2284 {
2285 match __value {
2286 0u8 => _serde::__private::Ok(__Field::__field0),
2287 1u8 => _serde::__private::Ok(__Field::__field1),
2288 2u8 => _serde::__private::Ok(__Field::__field2),
2289 3u8 => _serde::__private::Ok(__Field::__field3),
2290 4u8 => _serde::__private::Ok(__Field::__field4),
2291 _ => {
2292 _serde::__private::Err(
2293 _serde::de::Error::invalid_value(
2294 _serde::de::Unexpected::Uint8(__value),
2295 &"value(u8) of variant is one of 0, 1, 2, 3, 4",
2296 ),
2297 )
2298 }
2299 }
2300 }
2301 fn visit_stringptr<__E>(
2302 self,
2303 __value: StringPtr<'de>,
2304 ) -> _serde::__private::Result<Self::Value, __E>
2305 where
2306 __E: _serde::de::Error,
2307 {
2308 if let Some(__value) = __value.into_inner() {
2309 match __value.as_ref() {
2310 v if v == "0" || v.eq_ignore_ascii_case("MATERIAL_NONE") => {
2311 _serde::__private::Ok(__Field::__field0)
2312 }
2313 v if v == "1"
2314 || v
2315 .eq_ignore_ascii_case("MATERIAL_SINGLE_VALUE_PER_CHUNK") => {
2316 _serde::__private::Ok(__Field::__field1)
2317 }
2318 v if v == "2"
2319 || v
2320 .eq_ignore_ascii_case("MATERIAL_ONE_BYTE_PER_TRIANGLE") => {
2321 _serde::__private::Ok(__Field::__field2)
2322 }
2323 v if v == "3"
2324 || v
2325 .eq_ignore_ascii_case("MATERIAL_TWO_BYTES_PER_TRIANGLE") => {
2326 _serde::__private::Ok(__Field::__field3)
2327 }
2328 v if v == "4"
2329 || v
2330 .eq_ignore_ascii_case(
2331 "MATERIAL_FOUR_BYTES_PER_TRIANGLE",
2332 ) => _serde::__private::Ok(__Field::__field4),
2333 _ => {
2334 _serde::__private::Err(
2335 _serde::de::Error::unknown_variant(&__value, VARIANTS),
2336 )
2337 }
2338 }
2339 } else {
2340 _serde::__private::Err(
2341 _serde::de::Error::unknown_variant("None", VARIANTS),
2342 )
2343 }
2344 }
2345 }
2346 impl<'de> _serde::Deserialize<'de> for __Field {
2347 #[inline]
2348 fn deserialize<__D>(
2349 __deserializer: __D,
2350 ) -> _serde::__private::Result<Self, __D::Error>
2351 where
2352 __D: _serde::Deserializer<'de>,
2353 {
2354 _serde::Deserializer::deserialize_identifier(
2355 __deserializer,
2356 _serde::de::ReadEnumSize::Uint8,
2357 __FieldVisitor,
2358 )
2359 }
2360 }
2361 #[doc(hidden)]
2362 struct __Visitor<'de> {
2363 marker: _serde::__private::PhantomData<MaterialType>,
2364 lifetime: _serde::__private::PhantomData<&'de ()>,
2365 }
2366 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
2367 type Value = MaterialType;
2368 fn expecting(
2369 &self,
2370 __formatter: &mut _serde::__private::Formatter,
2371 ) -> _serde::__private::fmt::Result {
2372 _serde::__private::Formatter::write_str(
2373 __formatter,
2374 "enum MaterialType",
2375 )
2376 }
2377 fn visit_enum<__A>(
2378 self,
2379 __data: __A,
2380 ) -> _serde::__private::Result<Self::Value, __A::Error>
2381 where
2382 __A: _serde::de::EnumAccess<'de>,
2383 {
2384 match _serde::de::EnumAccess::variant(__data)? {
2385 (__Field::__field0, __variant) => {
2386 _serde::de::VariantAccess::unit_variant(__variant)?;
2387 _serde::__private::Ok(MaterialType::MATERIAL_NONE)
2388 }
2389 (__Field::__field1, __variant) => {
2390 _serde::de::VariantAccess::unit_variant(__variant)?;
2391 _serde::__private::Ok(
2392 MaterialType::MATERIAL_SINGLE_VALUE_PER_CHUNK,
2393 )
2394 }
2395 (__Field::__field2, __variant) => {
2396 _serde::de::VariantAccess::unit_variant(__variant)?;
2397 _serde::__private::Ok(
2398 MaterialType::MATERIAL_ONE_BYTE_PER_TRIANGLE,
2399 )
2400 }
2401 (__Field::__field3, __variant) => {
2402 _serde::de::VariantAccess::unit_variant(__variant)?;
2403 _serde::__private::Ok(
2404 MaterialType::MATERIAL_TWO_BYTES_PER_TRIANGLE,
2405 )
2406 }
2407 (__Field::__field4, __variant) => {
2408 _serde::de::VariantAccess::unit_variant(__variant)?;
2409 _serde::__private::Ok(
2410 MaterialType::MATERIAL_FOUR_BYTES_PER_TRIANGLE,
2411 )
2412 }
2413 }
2414 }
2415 }
2416 #[doc(hidden)]
2417 const VARIANTS: &'static [&'static str] = &[
2418 "MATERIAL_NONE",
2419 "MATERIAL_SINGLE_VALUE_PER_CHUNK",
2420 "MATERIAL_ONE_BYTE_PER_TRIANGLE",
2421 "MATERIAL_TWO_BYTES_PER_TRIANGLE",
2422 "MATERIAL_FOUR_BYTES_PER_TRIANGLE",
2423 ];
2424 _serde::Deserializer::deserialize_enum(
2425 __deserializer,
2426 "MaterialType",
2427 VARIANTS,
2428 __Visitor {
2429 marker: _serde::__private::PhantomData::<MaterialType>,
2430 lifetime: _serde::__private::PhantomData,
2431 },
2432 )
2433 }
2434 }
2435};