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 hkpStorageExtendedMeshShapeMeshSubpartStorage<'a> {
15 #[cfg_attr(
22 feature = "serde",
23 serde(skip_serializing_if = "Option::is_none", default)
24 )]
25 pub __ptr: Option<Pointer>,
26 #[cfg_attr(feature = "json_schema", schemars(flatten))]
28 #[cfg_attr(feature = "serde", serde(flatten))]
29 pub parent: hkReferencedObject,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "vertices"))]
35 #[cfg_attr(feature = "serde", serde(rename = "vertices"))]
36 pub m_vertices: Vec<Vector4>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "indices8"))]
42 #[cfg_attr(feature = "serde", serde(rename = "indices8"))]
43 pub m_indices8: Vec<u8>,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "indices16"))]
49 #[cfg_attr(feature = "serde", serde(rename = "indices16"))]
50 pub m_indices16: Vec<u16>,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "indices32"))]
56 #[cfg_attr(feature = "serde", serde(rename = "indices32"))]
57 pub m_indices32: Vec<u32>,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "materialIndices"))]
63 #[cfg_attr(feature = "serde", serde(rename = "materialIndices"))]
64 pub m_materialIndices: Vec<u8>,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "materials"))]
70 #[cfg_attr(feature = "serde", serde(rename = "materials"))]
71 pub m_materials: Vec<hkpStorageExtendedMeshShapeMaterial>,
72 #[cfg_attr(feature = "serde", serde(borrow))]
77 #[cfg_attr(feature = "json_schema", schemars(rename = "namedMaterials"))]
78 #[cfg_attr(feature = "serde", serde(rename = "namedMaterials"))]
79 pub m_namedMaterials: Vec<hkpNamedMeshMaterial<'a>>,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "materialIndices16"))]
85 #[cfg_attr(feature = "serde", serde(rename = "materialIndices16"))]
86 pub m_materialIndices16: Vec<u16>,
87}
88const _: () = {
89 use havok_serde as _serde;
90 impl<'a> _serde::HavokClass for hkpStorageExtendedMeshShapeMeshSubpartStorage<'a> {
91 #[inline]
92 fn name(&self) -> &'static str {
93 "hkpStorageExtendedMeshShapeMeshSubpartStorage"
94 }
95 #[inline]
96 fn signature(&self) -> _serde::__private::Signature {
97 _serde::__private::Signature::new(0x5aad4de6)
98 }
99 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
100 fn deps_indexes(&self) -> Vec<usize> {
101 let mut v = Vec::new();
102 v.extend(
103 self
104 .m_materials
105 .iter()
106 .flat_map(|class| class.deps_indexes())
107 .collect::<Vec<usize>>(),
108 );
109 v.extend(
110 self
111 .m_namedMaterials
112 .iter()
113 .flat_map(|class| class.deps_indexes())
114 .collect::<Vec<usize>>(),
115 );
116 v
117 }
118 }
119 impl<'a> _serde::Serialize for hkpStorageExtendedMeshShapeMeshSubpartStorage<'a> {
120 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
121 where
122 S: _serde::ser::Serializer,
123 {
124 let class_meta = self
125 .__ptr
126 .map(|name| (name, _serde::__private::Signature::new(0x5aad4de6)));
127 let mut serializer = __serializer
128 .serialize_struct(
129 "hkpStorageExtendedMeshShapeMeshSubpartStorage",
130 class_meta,
131 (104u64, 144u64),
132 )?;
133 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
134 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
135 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
136 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
137 serializer
138 .serialize_array_field("vertices", &self.m_vertices, TypeSize::NonPtr)?;
139 serializer
140 .serialize_array_field("indices8", &self.m_indices8, TypeSize::NonPtr)?;
141 serializer
142 .serialize_array_field(
143 "indices16",
144 &self.m_indices16,
145 TypeSize::NonPtr,
146 )?;
147 serializer
148 .serialize_array_field(
149 "indices32",
150 &self.m_indices32,
151 TypeSize::NonPtr,
152 )?;
153 serializer
154 .serialize_array_field(
155 "materialIndices",
156 &self.m_materialIndices,
157 TypeSize::NonPtr,
158 )?;
159 serializer
160 .serialize_array_field(
161 "materials",
162 &self.m_materials,
163 TypeSize::Struct {
164 size_x86: 12u64,
165 size_x86_64: 16u64,
166 },
167 )?;
168 serializer
169 .serialize_array_field(
170 "namedMaterials",
171 &self.m_namedMaterials,
172 TypeSize::Struct {
173 size_x86: 8u64,
174 size_x86_64: 16u64,
175 },
176 )?;
177 serializer
178 .serialize_array_field(
179 "materialIndices16",
180 &self.m_materialIndices16,
181 TypeSize::NonPtr,
182 )?;
183 serializer.end()
184 }
185 }
186};
187#[doc(hidden)]
188#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
189const _: () = {
190 use havok_serde as _serde;
191 #[automatically_derived]
192 impl<'de> _serde::Deserialize<'de>
193 for hkpStorageExtendedMeshShapeMeshSubpartStorage<'de> {
194 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
195 where
196 __D: _serde::Deserializer<'de>,
197 {
198 #[allow(non_camel_case_types)]
199 enum __Field {
200 m_vertices,
201 m_indices8,
202 m_indices16,
203 m_indices32,
204 m_materialIndices,
205 m_materials,
206 m_namedMaterials,
207 m_materialIndices16,
208 __ignore,
209 }
210 struct __FieldVisitor;
211 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
212 type Value = __Field;
213 fn expecting(
214 &self,
215 __formatter: &mut core::fmt::Formatter,
216 ) -> core::fmt::Result {
217 core::fmt::Formatter::write_str(__formatter, "field identifier")
218 }
219 #[allow(clippy::match_single_binding)]
221 #[allow(clippy::reversed_empty_ranges)]
222 #[allow(clippy::single_match)]
223 fn visit_key<__E>(
224 self,
225 __value: &str,
226 ) -> core::result::Result<Self::Value, __E>
227 where
228 __E: _serde::de::Error,
229 {
230 match __value {
231 "vertices" => Ok(__Field::m_vertices),
232 "indices8" => Ok(__Field::m_indices8),
233 "indices16" => Ok(__Field::m_indices16),
234 "indices32" => Ok(__Field::m_indices32),
235 "materialIndices" => Ok(__Field::m_materialIndices),
236 "materials" => Ok(__Field::m_materials),
237 "namedMaterials" => Ok(__Field::m_namedMaterials),
238 "materialIndices16" => Ok(__Field::m_materialIndices16),
239 _ => Ok(__Field::__ignore),
240 }
241 }
242 }
243 impl<'de> _serde::Deserialize<'de> for __Field {
244 #[inline]
245 fn deserialize<__D>(
246 __deserializer: __D,
247 ) -> core::result::Result<Self, __D::Error>
248 where
249 __D: _serde::Deserializer<'de>,
250 {
251 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
252 }
253 }
254 struct __hkpStorageExtendedMeshShapeMeshSubpartStorageVisitor<'de> {
255 marker: _serde::__private::PhantomData<
256 hkpStorageExtendedMeshShapeMeshSubpartStorage<'de>,
257 >,
258 lifetime: _serde::__private::PhantomData<&'de ()>,
259 }
260 #[allow(clippy::match_single_binding)]
261 #[allow(clippy::reversed_empty_ranges)]
262 #[allow(clippy::single_match)]
263 impl<'de> _serde::de::Visitor<'de>
264 for __hkpStorageExtendedMeshShapeMeshSubpartStorageVisitor<'de> {
265 type Value = hkpStorageExtendedMeshShapeMeshSubpartStorage<'de>;
266 fn expecting(
267 &self,
268 __formatter: &mut core::fmt::Formatter,
269 ) -> core::fmt::Result {
270 core::fmt::Formatter::write_str(
271 __formatter,
272 "struct hkpStorageExtendedMeshShapeMeshSubpartStorage",
273 )
274 }
275 fn visit_struct_for_bytes<__A>(
276 self,
277 mut __map: __A,
278 ) -> _serde::__private::Result<Self::Value, __A::Error>
279 where
280 __A: _serde::de::MapAccess<'de>,
281 {
282 let __ptr = __A::class_ptr(&mut __map);
283 let parent = __A::parent_value(&mut __map)?;
284 let mut m_vertices: _serde::__private::Option<Vec<Vector4>> = _serde::__private::None;
285 let mut m_indices8: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
286 let mut m_indices16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
287 let mut m_indices32: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
288 let mut m_materialIndices: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
289 let mut m_materials: _serde::__private::Option<
290 Vec<hkpStorageExtendedMeshShapeMaterial>,
291 > = _serde::__private::None;
292 let mut m_namedMaterials: _serde::__private::Option<
293 Vec<hkpNamedMeshMaterial<'de>>,
294 > = _serde::__private::None;
295 let mut m_materialIndices16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
296 for i in 0..8usize {
297 match i {
298 0usize => {
299 if _serde::__private::Option::is_some(&m_vertices) {
300 return _serde::__private::Err(
301 <__A::Error as _serde::de::Error>::duplicate_field(
302 "vertices",
303 ),
304 );
305 }
306 m_vertices = _serde::__private::Some(
307 match __A::next_value::<Vec<Vector4>>(&mut __map) {
308 _serde::__private::Ok(__val) => __val,
309 _serde::__private::Err(__err) => {
310 return _serde::__private::Err(__err);
311 }
312 },
313 );
314 }
315 1usize => {
316 if _serde::__private::Option::is_some(&m_indices8) {
317 return _serde::__private::Err(
318 <__A::Error as _serde::de::Error>::duplicate_field(
319 "indices8",
320 ),
321 );
322 }
323 m_indices8 = _serde::__private::Some(
324 match __A::next_value::<Vec<u8>>(&mut __map) {
325 _serde::__private::Ok(__val) => __val,
326 _serde::__private::Err(__err) => {
327 return _serde::__private::Err(__err);
328 }
329 },
330 );
331 }
332 2usize => {
333 if _serde::__private::Option::is_some(&m_indices16) {
334 return _serde::__private::Err(
335 <__A::Error as _serde::de::Error>::duplicate_field(
336 "indices16",
337 ),
338 );
339 }
340 m_indices16 = _serde::__private::Some(
341 match __A::next_value::<Vec<u16>>(&mut __map) {
342 _serde::__private::Ok(__val) => __val,
343 _serde::__private::Err(__err) => {
344 return _serde::__private::Err(__err);
345 }
346 },
347 );
348 }
349 3usize => {
350 if _serde::__private::Option::is_some(&m_indices32) {
351 return _serde::__private::Err(
352 <__A::Error as _serde::de::Error>::duplicate_field(
353 "indices32",
354 ),
355 );
356 }
357 m_indices32 = _serde::__private::Some(
358 match __A::next_value::<Vec<u32>>(&mut __map) {
359 _serde::__private::Ok(__val) => __val,
360 _serde::__private::Err(__err) => {
361 return _serde::__private::Err(__err);
362 }
363 },
364 );
365 }
366 4usize => {
367 if _serde::__private::Option::is_some(&m_materialIndices) {
368 return _serde::__private::Err(
369 <__A::Error as _serde::de::Error>::duplicate_field(
370 "materialIndices",
371 ),
372 );
373 }
374 m_materialIndices = _serde::__private::Some(
375 match __A::next_value::<Vec<u8>>(&mut __map) {
376 _serde::__private::Ok(__val) => __val,
377 _serde::__private::Err(__err) => {
378 return _serde::__private::Err(__err);
379 }
380 },
381 );
382 }
383 5usize => {
384 if _serde::__private::Option::is_some(&m_materials) {
385 return _serde::__private::Err(
386 <__A::Error as _serde::de::Error>::duplicate_field(
387 "materials",
388 ),
389 );
390 }
391 m_materials = _serde::__private::Some(
392 match __A::next_value::<
393 Vec<hkpStorageExtendedMeshShapeMaterial>,
394 >(&mut __map) {
395 _serde::__private::Ok(__val) => __val,
396 _serde::__private::Err(__err) => {
397 return _serde::__private::Err(__err);
398 }
399 },
400 );
401 }
402 6usize => {
403 if _serde::__private::Option::is_some(&m_namedMaterials) {
404 return _serde::__private::Err(
405 <__A::Error as _serde::de::Error>::duplicate_field(
406 "namedMaterials",
407 ),
408 );
409 }
410 m_namedMaterials = _serde::__private::Some(
411 match __A::next_value::<
412 Vec<hkpNamedMeshMaterial<'de>>,
413 >(&mut __map) {
414 _serde::__private::Ok(__val) => __val,
415 _serde::__private::Err(__err) => {
416 return _serde::__private::Err(__err);
417 }
418 },
419 );
420 }
421 7usize => {
422 if _serde::__private::Option::is_some(
423 &m_materialIndices16,
424 ) {
425 return _serde::__private::Err(
426 <__A::Error as _serde::de::Error>::duplicate_field(
427 "materialIndices16",
428 ),
429 );
430 }
431 m_materialIndices16 = _serde::__private::Some(
432 match __A::next_value::<Vec<u16>>(&mut __map) {
433 _serde::__private::Ok(__val) => __val,
434 _serde::__private::Err(__err) => {
435 return _serde::__private::Err(__err);
436 }
437 },
438 );
439 }
440 _ => {}
441 }
442 }
443 let m_vertices = match m_vertices {
444 _serde::__private::Some(__field) => __field,
445 _serde::__private::None => {
446 return _serde::__private::Err(
447 <__A::Error as _serde::de::Error>::missing_field("vertices"),
448 );
449 }
450 };
451 let m_indices8 = match m_indices8 {
452 _serde::__private::Some(__field) => __field,
453 _serde::__private::None => {
454 return _serde::__private::Err(
455 <__A::Error as _serde::de::Error>::missing_field("indices8"),
456 );
457 }
458 };
459 let m_indices16 = match m_indices16 {
460 _serde::__private::Some(__field) => __field,
461 _serde::__private::None => {
462 return _serde::__private::Err(
463 <__A::Error as _serde::de::Error>::missing_field(
464 "indices16",
465 ),
466 );
467 }
468 };
469 let m_indices32 = match m_indices32 {
470 _serde::__private::Some(__field) => __field,
471 _serde::__private::None => {
472 return _serde::__private::Err(
473 <__A::Error as _serde::de::Error>::missing_field(
474 "indices32",
475 ),
476 );
477 }
478 };
479 let m_materialIndices = match m_materialIndices {
480 _serde::__private::Some(__field) => __field,
481 _serde::__private::None => {
482 return _serde::__private::Err(
483 <__A::Error as _serde::de::Error>::missing_field(
484 "materialIndices",
485 ),
486 );
487 }
488 };
489 let m_materials = match m_materials {
490 _serde::__private::Some(__field) => __field,
491 _serde::__private::None => {
492 return _serde::__private::Err(
493 <__A::Error as _serde::de::Error>::missing_field(
494 "materials",
495 ),
496 );
497 }
498 };
499 let m_namedMaterials = match m_namedMaterials {
500 _serde::__private::Some(__field) => __field,
501 _serde::__private::None => {
502 return _serde::__private::Err(
503 <__A::Error as _serde::de::Error>::missing_field(
504 "namedMaterials",
505 ),
506 );
507 }
508 };
509 let m_materialIndices16 = match m_materialIndices16 {
510 _serde::__private::Some(__field) => __field,
511 _serde::__private::None => {
512 return _serde::__private::Err(
513 <__A::Error as _serde::de::Error>::missing_field(
514 "materialIndices16",
515 ),
516 );
517 }
518 };
519 _serde::__private::Ok(hkpStorageExtendedMeshShapeMeshSubpartStorage {
520 __ptr,
521 parent,
522 m_vertices,
523 m_indices8,
524 m_indices16,
525 m_indices32,
526 m_materialIndices,
527 m_materials,
528 m_namedMaterials,
529 m_materialIndices16,
530 })
531 }
532 #[allow(clippy::manual_unwrap_or_default)]
533 fn visit_struct<__A>(
534 self,
535 mut __map: __A,
536 ) -> _serde::__private::Result<Self::Value, __A::Error>
537 where
538 __A: _serde::de::MapAccess<'de>,
539 {
540 let mut m_vertices: _serde::__private::Option<Vec<Vector4>> = _serde::__private::None;
541 let mut m_indices8: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
542 let mut m_indices16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
543 let mut m_indices32: _serde::__private::Option<Vec<u32>> = _serde::__private::None;
544 let mut m_materialIndices: _serde::__private::Option<Vec<u8>> = _serde::__private::None;
545 let mut m_materials: _serde::__private::Option<
546 Vec<hkpStorageExtendedMeshShapeMaterial>,
547 > = _serde::__private::None;
548 let mut m_namedMaterials: _serde::__private::Option<
549 Vec<hkpNamedMeshMaterial<'de>>,
550 > = _serde::__private::None;
551 let mut m_materialIndices16: _serde::__private::Option<Vec<u16>> = _serde::__private::None;
552 while let _serde::__private::Some(__key) = {
553 __A::next_key::<__Field>(&mut __map)?
554 } {
555 match __key {
556 __Field::m_vertices => {
557 #[cfg(
558 any(feature = "strict", feature = "ignore_duplicates")
559 )]
560 if _serde::__private::Option::is_some(&m_vertices) {
561 #[cfg(feature = "ignore_duplicates")]
562 {
563 __A::skip_value(&mut __map)?;
564 continue;
565 }
566 #[cfg(feature = "strict")]
567 return _serde::__private::Err(
568 <__A::Error as _serde::de::Error>::duplicate_field(
569 "vertices",
570 ),
571 );
572 }
573 m_vertices = _serde::__private::Some(
574 match __A::next_value::<Vec<Vector4>>(&mut __map) {
575 _serde::__private::Ok(__val) => __val,
576 _serde::__private::Err(__err) => {
577 return _serde::__private::Err(__err);
578 }
579 },
580 );
581 }
582 __Field::m_indices8 => {
583 #[cfg(
584 any(feature = "strict", feature = "ignore_duplicates")
585 )]
586 if _serde::__private::Option::is_some(&m_indices8) {
587 #[cfg(feature = "ignore_duplicates")]
588 {
589 __A::skip_value(&mut __map)?;
590 continue;
591 }
592 #[cfg(feature = "strict")]
593 return _serde::__private::Err(
594 <__A::Error as _serde::de::Error>::duplicate_field(
595 "indices8",
596 ),
597 );
598 }
599 m_indices8 = _serde::__private::Some(
600 match __A::next_value::<Vec<u8>>(&mut __map) {
601 _serde::__private::Ok(__val) => __val,
602 _serde::__private::Err(__err) => {
603 return _serde::__private::Err(__err);
604 }
605 },
606 );
607 }
608 __Field::m_indices16 => {
609 #[cfg(
610 any(feature = "strict", feature = "ignore_duplicates")
611 )]
612 if _serde::__private::Option::is_some(&m_indices16) {
613 #[cfg(feature = "ignore_duplicates")]
614 {
615 __A::skip_value(&mut __map)?;
616 continue;
617 }
618 #[cfg(feature = "strict")]
619 return _serde::__private::Err(
620 <__A::Error as _serde::de::Error>::duplicate_field(
621 "indices16",
622 ),
623 );
624 }
625 m_indices16 = _serde::__private::Some(
626 match __A::next_value::<Vec<u16>>(&mut __map) {
627 _serde::__private::Ok(__val) => __val,
628 _serde::__private::Err(__err) => {
629 return _serde::__private::Err(__err);
630 }
631 },
632 );
633 }
634 __Field::m_indices32 => {
635 #[cfg(
636 any(feature = "strict", feature = "ignore_duplicates")
637 )]
638 if _serde::__private::Option::is_some(&m_indices32) {
639 #[cfg(feature = "ignore_duplicates")]
640 {
641 __A::skip_value(&mut __map)?;
642 continue;
643 }
644 #[cfg(feature = "strict")]
645 return _serde::__private::Err(
646 <__A::Error as _serde::de::Error>::duplicate_field(
647 "indices32",
648 ),
649 );
650 }
651 m_indices32 = _serde::__private::Some(
652 match __A::next_value::<Vec<u32>>(&mut __map) {
653 _serde::__private::Ok(__val) => __val,
654 _serde::__private::Err(__err) => {
655 return _serde::__private::Err(__err);
656 }
657 },
658 );
659 }
660 __Field::m_materialIndices => {
661 #[cfg(
662 any(feature = "strict", feature = "ignore_duplicates")
663 )]
664 if _serde::__private::Option::is_some(&m_materialIndices) {
665 #[cfg(feature = "ignore_duplicates")]
666 {
667 __A::skip_value(&mut __map)?;
668 continue;
669 }
670 #[cfg(feature = "strict")]
671 return _serde::__private::Err(
672 <__A::Error as _serde::de::Error>::duplicate_field(
673 "materialIndices",
674 ),
675 );
676 }
677 m_materialIndices = _serde::__private::Some(
678 match __A::next_value::<Vec<u8>>(&mut __map) {
679 _serde::__private::Ok(__val) => __val,
680 _serde::__private::Err(__err) => {
681 return _serde::__private::Err(__err);
682 }
683 },
684 );
685 }
686 __Field::m_materials => {
687 #[cfg(
688 any(feature = "strict", feature = "ignore_duplicates")
689 )]
690 if _serde::__private::Option::is_some(&m_materials) {
691 #[cfg(feature = "ignore_duplicates")]
692 {
693 __A::skip_value(&mut __map)?;
694 continue;
695 }
696 #[cfg(feature = "strict")]
697 return _serde::__private::Err(
698 <__A::Error as _serde::de::Error>::duplicate_field(
699 "materials",
700 ),
701 );
702 }
703 m_materials = _serde::__private::Some(
704 match __A::next_value::<
705 Vec<hkpStorageExtendedMeshShapeMaterial>,
706 >(&mut __map) {
707 _serde::__private::Ok(__val) => __val,
708 _serde::__private::Err(__err) => {
709 return _serde::__private::Err(__err);
710 }
711 },
712 );
713 }
714 __Field::m_namedMaterials => {
715 #[cfg(
716 any(feature = "strict", feature = "ignore_duplicates")
717 )]
718 if _serde::__private::Option::is_some(&m_namedMaterials) {
719 #[cfg(feature = "ignore_duplicates")]
720 {
721 __A::skip_value(&mut __map)?;
722 continue;
723 }
724 #[cfg(feature = "strict")]
725 return _serde::__private::Err(
726 <__A::Error as _serde::de::Error>::duplicate_field(
727 "namedMaterials",
728 ),
729 );
730 }
731 m_namedMaterials = _serde::__private::Some(
732 match __A::next_value::<
733 Vec<hkpNamedMeshMaterial<'de>>,
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 __Field::m_materialIndices16 => {
743 #[cfg(
744 any(feature = "strict", feature = "ignore_duplicates")
745 )]
746 if _serde::__private::Option::is_some(
747 &m_materialIndices16,
748 ) {
749 #[cfg(feature = "ignore_duplicates")]
750 {
751 __A::skip_value(&mut __map)?;
752 continue;
753 }
754 #[cfg(feature = "strict")]
755 return _serde::__private::Err(
756 <__A::Error as _serde::de::Error>::duplicate_field(
757 "materialIndices16",
758 ),
759 );
760 }
761 m_materialIndices16 = _serde::__private::Some(
762 match __A::next_value::<Vec<u16>>(&mut __map) {
763 _serde::__private::Ok(__val) => __val,
764 _serde::__private::Err(__err) => {
765 return _serde::__private::Err(__err);
766 }
767 },
768 );
769 }
770 _ => __A::skip_value(&mut __map)?,
771 }
772 }
773 let m_vertices = match m_vertices {
774 _serde::__private::Some(__field) => __field,
775 _serde::__private::None => {
776 #[cfg(feature = "strict")]
777 return _serde::__private::Err(
778 <__A::Error as _serde::de::Error>::missing_field("vertices"),
779 );
780 #[cfg(not(feature = "strict"))] Default::default()
781 }
782 };
783 let m_indices8 = match m_indices8 {
784 _serde::__private::Some(__field) => __field,
785 _serde::__private::None => {
786 #[cfg(feature = "strict")]
787 return _serde::__private::Err(
788 <__A::Error as _serde::de::Error>::missing_field("indices8"),
789 );
790 #[cfg(not(feature = "strict"))] Default::default()
791 }
792 };
793 let m_indices16 = match m_indices16 {
794 _serde::__private::Some(__field) => __field,
795 _serde::__private::None => {
796 #[cfg(feature = "strict")]
797 return _serde::__private::Err(
798 <__A::Error as _serde::de::Error>::missing_field(
799 "indices16",
800 ),
801 );
802 #[cfg(not(feature = "strict"))] Default::default()
803 }
804 };
805 let m_indices32 = match m_indices32 {
806 _serde::__private::Some(__field) => __field,
807 _serde::__private::None => {
808 #[cfg(feature = "strict")]
809 return _serde::__private::Err(
810 <__A::Error as _serde::de::Error>::missing_field(
811 "indices32",
812 ),
813 );
814 #[cfg(not(feature = "strict"))] Default::default()
815 }
816 };
817 let m_materialIndices = match m_materialIndices {
818 _serde::__private::Some(__field) => __field,
819 _serde::__private::None => {
820 #[cfg(feature = "strict")]
821 return _serde::__private::Err(
822 <__A::Error as _serde::de::Error>::missing_field(
823 "materialIndices",
824 ),
825 );
826 #[cfg(not(feature = "strict"))] Default::default()
827 }
828 };
829 let m_materials = match m_materials {
830 _serde::__private::Some(__field) => __field,
831 _serde::__private::None => {
832 #[cfg(feature = "strict")]
833 return _serde::__private::Err(
834 <__A::Error as _serde::de::Error>::missing_field(
835 "materials",
836 ),
837 );
838 #[cfg(not(feature = "strict"))] Default::default()
839 }
840 };
841 let m_namedMaterials = match m_namedMaterials {
842 _serde::__private::Some(__field) => __field,
843 _serde::__private::None => {
844 #[cfg(feature = "strict")]
845 return _serde::__private::Err(
846 <__A::Error as _serde::de::Error>::missing_field(
847 "namedMaterials",
848 ),
849 );
850 #[cfg(not(feature = "strict"))] Default::default()
851 }
852 };
853 let m_materialIndices16 = match m_materialIndices16 {
854 _serde::__private::Some(__field) => __field,
855 _serde::__private::None => {
856 #[cfg(feature = "strict")]
857 return _serde::__private::Err(
858 <__A::Error as _serde::de::Error>::missing_field(
859 "materialIndices16",
860 ),
861 );
862 #[cfg(not(feature = "strict"))] Default::default()
863 }
864 };
865 let __ptr = None;
866 let parent = hkBaseObject { __ptr };
867 let parent = hkReferencedObject {
868 __ptr,
869 parent,
870 ..Default::default()
871 };
872 let __ptr = __A::class_ptr(&mut __map);
873 _serde::__private::Ok(hkpStorageExtendedMeshShapeMeshSubpartStorage {
874 __ptr,
875 parent,
876 m_vertices,
877 m_indices8,
878 m_indices16,
879 m_indices32,
880 m_materialIndices,
881 m_materials,
882 m_namedMaterials,
883 m_materialIndices16,
884 })
885 }
886 }
887 const FIELDS: &[&str] = &[
888 "vertices",
889 "indices8",
890 "indices16",
891 "indices32",
892 "materialIndices",
893 "materials",
894 "namedMaterials",
895 "materialIndices16",
896 ];
897 _serde::Deserializer::deserialize_struct(
898 deserializer,
899 "hkpStorageExtendedMeshShapeMeshSubpartStorage",
900 FIELDS,
901 __hkpStorageExtendedMeshShapeMeshSubpartStorageVisitor {
902 marker: _serde::__private::PhantomData::<
903 hkpStorageExtendedMeshShapeMeshSubpartStorage,
904 >,
905 lifetime: _serde::__private::PhantomData,
906 },
907 )
908 }
909 }
910};