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