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 hkpExtendedMeshShapeTrianglesSubpart {
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: hkpExtendedMeshShapeSubpart,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "numTriangleShapes"))]
35 #[cfg_attr(feature = "serde", serde(rename = "numTriangleShapes"))]
36 pub m_numTriangleShapes: i32,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "vertexBase"))]
43 #[cfg_attr(feature = "serde", serde(rename = "vertexBase"))]
44 pub m_vertexBase: Pointer,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "numVertices"))]
50 #[cfg_attr(feature = "serde", serde(rename = "numVertices"))]
51 pub m_numVertices: i32,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "indexBase"))]
58 #[cfg_attr(feature = "serde", serde(rename = "indexBase"))]
59 pub m_indexBase: Pointer,
60 #[cfg_attr(feature = "json_schema", schemars(rename = "vertexStriding"))]
65 #[cfg_attr(feature = "serde", serde(rename = "vertexStriding"))]
66 pub m_vertexStriding: u16,
67 #[cfg_attr(feature = "json_schema", schemars(rename = "triangleOffset"))]
72 #[cfg_attr(feature = "serde", serde(rename = "triangleOffset"))]
73 pub m_triangleOffset: i32,
74 #[cfg_attr(feature = "json_schema", schemars(rename = "indexStriding"))]
79 #[cfg_attr(feature = "serde", serde(rename = "indexStriding"))]
80 pub m_indexStriding: u16,
81 #[cfg_attr(feature = "json_schema", schemars(rename = "stridingType"))]
86 #[cfg_attr(feature = "serde", serde(rename = "stridingType"))]
87 pub m_stridingType: IndexStridingType,
88 #[cfg_attr(feature = "json_schema", schemars(rename = "flipAlternateTriangles"))]
93 #[cfg_attr(feature = "serde", serde(rename = "flipAlternateTriangles"))]
94 pub m_flipAlternateTriangles: i8,
95 #[cfg_attr(feature = "json_schema", schemars(rename = "extrusion"))]
100 #[cfg_attr(feature = "serde", serde(rename = "extrusion"))]
101 pub m_extrusion: Vector4,
102 #[cfg_attr(feature = "json_schema", schemars(rename = "transform"))]
107 #[cfg_attr(feature = "serde", serde(rename = "transform"))]
108 pub m_transform: QsTransform,
109}
110const _: () = {
111 use havok_serde as _serde;
112 impl _serde::HavokClass for hkpExtendedMeshShapeTrianglesSubpart {
113 #[inline]
114 fn name(&self) -> &'static str {
115 "hkpExtendedMeshShapeTrianglesSubpart"
116 }
117 #[inline]
118 fn signature(&self) -> _serde::__private::Signature {
119 _serde::__private::Signature::new(0x44c32df6)
120 }
121 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
122 fn deps_indexes(&self) -> Vec<usize> {
123 let mut v = Vec::new();
124 v.push(self.parent.m_materialIndexBase.get());
125 v.push(self.parent.m_materialBase.get());
126 v.push(self.m_vertexBase.get());
127 v.push(self.m_indexBase.get());
128 v
129 }
130 }
131 impl _serde::Serialize for hkpExtendedMeshShapeTrianglesSubpart {
132 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
133 where
134 S: _serde::ser::Serializer,
135 {
136 let class_meta = self
137 .__ptr
138 .map(|name| (name, _serde::__private::Signature::new(0x44c32df6)));
139 let mut serializer = __serializer
140 .serialize_struct(
141 "hkpExtendedMeshShapeTrianglesSubpart",
142 class_meta,
143 (112u64, 160u64),
144 )?;
145 serializer.serialize_field("type", &self.parent.m_type)?;
146 serializer
147 .serialize_field(
148 "materialIndexStridingType",
149 &self.parent.m_materialIndexStridingType,
150 )?;
151 serializer.skip_field("materialStriding", &self.parent.m_materialStriding)?;
152 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
153 serializer
154 .skip_field("materialIndexBase", &self.parent.m_materialIndexBase)?;
155 serializer
156 .serialize_field(
157 "materialIndexStriding",
158 &self.parent.m_materialIndexStriding,
159 )?;
160 serializer.serialize_field("numMaterials", &self.parent.m_numMaterials)?;
161 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
162 serializer.skip_field("materialBase", &self.parent.m_materialBase)?;
163 serializer.serialize_field("userData", &self.parent.m_userData)?;
164 serializer.serialize_field("numTriangleShapes", &self.m_numTriangleShapes)?;
165 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
166 serializer.skip_field("vertexBase", &self.m_vertexBase)?;
167 serializer.serialize_field("numVertices", &self.m_numVertices)?;
168 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
169 serializer.skip_field("indexBase", &self.m_indexBase)?;
170 serializer.serialize_field("vertexStriding", &self.m_vertexStriding)?;
171 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
172 serializer.serialize_field("triangleOffset", &self.m_triangleOffset)?;
173 serializer.serialize_field("indexStriding", &self.m_indexStriding)?;
174 serializer.serialize_field("stridingType", &self.m_stridingType)?;
175 serializer
176 .serialize_field(
177 "flipAlternateTriangles",
178 &self.m_flipAlternateTriangles,
179 )?;
180 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 12usize].as_slice())?;
181 serializer.serialize_field("extrusion", &self.m_extrusion)?;
182 serializer.serialize_field("transform", &self.m_transform)?;
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> for hkpExtendedMeshShapeTrianglesSubpart {
193 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
194 where
195 __D: _serde::Deserializer<'de>,
196 {
197 #[allow(non_camel_case_types)]
198 enum __Field {
199 m_type,
200 m_materialIndexStridingType,
201 m_materialIndexStriding,
202 m_numMaterials,
203 m_userData,
204 m_numTriangleShapes,
205 m_numVertices,
206 m_vertexStriding,
207 m_triangleOffset,
208 m_indexStriding,
209 m_stridingType,
210 m_flipAlternateTriangles,
211 m_extrusion,
212 m_transform,
213 __ignore,
214 }
215 struct __FieldVisitor;
216 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
217 type Value = __Field;
218 fn expecting(
219 &self,
220 __formatter: &mut core::fmt::Formatter,
221 ) -> core::fmt::Result {
222 core::fmt::Formatter::write_str(__formatter, "field identifier")
223 }
224 #[allow(clippy::match_single_binding)]
226 #[allow(clippy::reversed_empty_ranges)]
227 #[allow(clippy::single_match)]
228 fn visit_key<__E>(
229 self,
230 __value: &str,
231 ) -> core::result::Result<Self::Value, __E>
232 where
233 __E: _serde::de::Error,
234 {
235 match __value {
236 "type" => Ok(__Field::m_type),
237 "materialIndexStridingType" => {
238 Ok(__Field::m_materialIndexStridingType)
239 }
240 "materialIndexStriding" => Ok(__Field::m_materialIndexStriding),
241 "numMaterials" => Ok(__Field::m_numMaterials),
242 "userData" => Ok(__Field::m_userData),
243 "numTriangleShapes" => Ok(__Field::m_numTriangleShapes),
244 "numVertices" => Ok(__Field::m_numVertices),
245 "vertexStriding" => Ok(__Field::m_vertexStriding),
246 "triangleOffset" => Ok(__Field::m_triangleOffset),
247 "indexStriding" => Ok(__Field::m_indexStriding),
248 "stridingType" => Ok(__Field::m_stridingType),
249 "flipAlternateTriangles" => Ok(__Field::m_flipAlternateTriangles),
250 "extrusion" => Ok(__Field::m_extrusion),
251 "transform" => Ok(__Field::m_transform),
252 _ => Ok(__Field::__ignore),
253 }
254 }
255 }
256 impl<'de> _serde::Deserialize<'de> for __Field {
257 #[inline]
258 fn deserialize<__D>(
259 __deserializer: __D,
260 ) -> core::result::Result<Self, __D::Error>
261 where
262 __D: _serde::Deserializer<'de>,
263 {
264 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
265 }
266 }
267 struct __hkpExtendedMeshShapeTrianglesSubpartVisitor<'de> {
268 marker: _serde::__private::PhantomData<
269 hkpExtendedMeshShapeTrianglesSubpart,
270 >,
271 lifetime: _serde::__private::PhantomData<&'de ()>,
272 }
273 #[allow(clippy::match_single_binding)]
274 #[allow(clippy::reversed_empty_ranges)]
275 #[allow(clippy::single_match)]
276 impl<'de> _serde::de::Visitor<'de>
277 for __hkpExtendedMeshShapeTrianglesSubpartVisitor<'de> {
278 type Value = hkpExtendedMeshShapeTrianglesSubpart;
279 fn expecting(
280 &self,
281 __formatter: &mut core::fmt::Formatter,
282 ) -> core::fmt::Result {
283 core::fmt::Formatter::write_str(
284 __formatter,
285 "struct hkpExtendedMeshShapeTrianglesSubpart",
286 )
287 }
288 fn visit_struct_for_bytes<__A>(
289 self,
290 mut __map: __A,
291 ) -> _serde::__private::Result<Self::Value, __A::Error>
292 where
293 __A: _serde::de::MapAccess<'de>,
294 {
295 let __ptr = __A::class_ptr(&mut __map);
296 let parent = __A::parent_value(&mut __map)?;
297 let mut m_numTriangleShapes: _serde::__private::Option<i32> = _serde::__private::None;
298 let mut m_vertexBase: _serde::__private::Option<Pointer> = _serde::__private::None;
299 let mut m_numVertices: _serde::__private::Option<i32> = _serde::__private::None;
300 let mut m_indexBase: _serde::__private::Option<Pointer> = _serde::__private::None;
301 let mut m_vertexStriding: _serde::__private::Option<u16> = _serde::__private::None;
302 let mut m_triangleOffset: _serde::__private::Option<i32> = _serde::__private::None;
303 let mut m_indexStriding: _serde::__private::Option<u16> = _serde::__private::None;
304 let mut m_stridingType: _serde::__private::Option<
305 IndexStridingType,
306 > = _serde::__private::None;
307 let mut m_flipAlternateTriangles: _serde::__private::Option<i8> = _serde::__private::None;
308 let mut m_extrusion: _serde::__private::Option<Vector4> = _serde::__private::None;
309 let mut m_transform: _serde::__private::Option<QsTransform> = _serde::__private::None;
310 for i in 0..11usize {
311 match i {
312 0usize => {
313 if _serde::__private::Option::is_some(
314 &m_numTriangleShapes,
315 ) {
316 return _serde::__private::Err(
317 <__A::Error as _serde::de::Error>::duplicate_field(
318 "numTriangleShapes",
319 ),
320 );
321 }
322 m_numTriangleShapes = _serde::__private::Some(
323 match __A::next_value::<i32>(&mut __map) {
324 _serde::__private::Ok(__val) => __val,
325 _serde::__private::Err(__err) => {
326 return _serde::__private::Err(__err);
327 }
328 },
329 );
330 }
331 1usize => {
332 if _serde::__private::Option::is_some(&m_vertexBase) {
333 return _serde::__private::Err(
334 <__A::Error as _serde::de::Error>::duplicate_field(
335 "vertexBase",
336 ),
337 );
338 }
339 __A::pad(&mut __map, 0usize, 4usize)?;
340 m_vertexBase = _serde::__private::Some(
341 match __A::next_value::<Pointer>(&mut __map) {
342 _serde::__private::Ok(__val) => __val,
343 _serde::__private::Err(__err) => {
344 return _serde::__private::Err(__err);
345 }
346 },
347 );
348 }
349 2usize => {
350 if _serde::__private::Option::is_some(&m_numVertices) {
351 return _serde::__private::Err(
352 <__A::Error as _serde::de::Error>::duplicate_field(
353 "numVertices",
354 ),
355 );
356 }
357 m_numVertices = _serde::__private::Some(
358 match __A::next_value::<i32>(&mut __map) {
359 _serde::__private::Ok(__val) => __val,
360 _serde::__private::Err(__err) => {
361 return _serde::__private::Err(__err);
362 }
363 },
364 );
365 }
366 3usize => {
367 if _serde::__private::Option::is_some(&m_indexBase) {
368 return _serde::__private::Err(
369 <__A::Error as _serde::de::Error>::duplicate_field(
370 "indexBase",
371 ),
372 );
373 }
374 __A::pad(&mut __map, 0usize, 4usize)?;
375 m_indexBase = _serde::__private::Some(
376 match __A::next_value::<Pointer>(&mut __map) {
377 _serde::__private::Ok(__val) => __val,
378 _serde::__private::Err(__err) => {
379 return _serde::__private::Err(__err);
380 }
381 },
382 );
383 }
384 4usize => {
385 if _serde::__private::Option::is_some(&m_vertexStriding) {
386 return _serde::__private::Err(
387 <__A::Error as _serde::de::Error>::duplicate_field(
388 "vertexStriding",
389 ),
390 );
391 }
392 m_vertexStriding = _serde::__private::Some(
393 match __A::next_value::<u16>(&mut __map) {
394 _serde::__private::Ok(__val) => __val,
395 _serde::__private::Err(__err) => {
396 return _serde::__private::Err(__err);
397 }
398 },
399 );
400 }
401 5usize => {
402 if _serde::__private::Option::is_some(&m_triangleOffset) {
403 return _serde::__private::Err(
404 <__A::Error as _serde::de::Error>::duplicate_field(
405 "triangleOffset",
406 ),
407 );
408 }
409 __A::pad(&mut __map, 2usize, 2usize)?;
410 m_triangleOffset = _serde::__private::Some(
411 match __A::next_value::<i32>(&mut __map) {
412 _serde::__private::Ok(__val) => __val,
413 _serde::__private::Err(__err) => {
414 return _serde::__private::Err(__err);
415 }
416 },
417 );
418 }
419 6usize => {
420 if _serde::__private::Option::is_some(&m_indexStriding) {
421 return _serde::__private::Err(
422 <__A::Error as _serde::de::Error>::duplicate_field(
423 "indexStriding",
424 ),
425 );
426 }
427 m_indexStriding = _serde::__private::Some(
428 match __A::next_value::<u16>(&mut __map) {
429 _serde::__private::Ok(__val) => __val,
430 _serde::__private::Err(__err) => {
431 return _serde::__private::Err(__err);
432 }
433 },
434 );
435 }
436 7usize => {
437 if _serde::__private::Option::is_some(&m_stridingType) {
438 return _serde::__private::Err(
439 <__A::Error as _serde::de::Error>::duplicate_field(
440 "stridingType",
441 ),
442 );
443 }
444 m_stridingType = _serde::__private::Some(
445 match __A::next_value::<IndexStridingType>(&mut __map) {
446 _serde::__private::Ok(__val) => __val,
447 _serde::__private::Err(__err) => {
448 return _serde::__private::Err(__err);
449 }
450 },
451 );
452 }
453 8usize => {
454 if _serde::__private::Option::is_some(
455 &m_flipAlternateTriangles,
456 ) {
457 return _serde::__private::Err(
458 <__A::Error as _serde::de::Error>::duplicate_field(
459 "flipAlternateTriangles",
460 ),
461 );
462 }
463 m_flipAlternateTriangles = _serde::__private::Some(
464 match __A::next_value::<i8>(&mut __map) {
465 _serde::__private::Ok(__val) => __val,
466 _serde::__private::Err(__err) => {
467 return _serde::__private::Err(__err);
468 }
469 },
470 );
471 }
472 9usize => {
473 if _serde::__private::Option::is_some(&m_extrusion) {
474 return _serde::__private::Err(
475 <__A::Error as _serde::de::Error>::duplicate_field(
476 "extrusion",
477 ),
478 );
479 }
480 __A::pad(&mut __map, 0usize, 12usize)?;
481 m_extrusion = _serde::__private::Some(
482 match __A::next_value::<Vector4>(&mut __map) {
483 _serde::__private::Ok(__val) => __val,
484 _serde::__private::Err(__err) => {
485 return _serde::__private::Err(__err);
486 }
487 },
488 );
489 }
490 10usize => {
491 if _serde::__private::Option::is_some(&m_transform) {
492 return _serde::__private::Err(
493 <__A::Error as _serde::de::Error>::duplicate_field(
494 "transform",
495 ),
496 );
497 }
498 m_transform = _serde::__private::Some(
499 match __A::next_value::<QsTransform>(&mut __map) {
500 _serde::__private::Ok(__val) => __val,
501 _serde::__private::Err(__err) => {
502 return _serde::__private::Err(__err);
503 }
504 },
505 );
506 }
507 _ => {}
508 }
509 }
510 let m_numTriangleShapes = match m_numTriangleShapes {
511 _serde::__private::Some(__field) => __field,
512 _serde::__private::None => {
513 return _serde::__private::Err(
514 <__A::Error as _serde::de::Error>::missing_field(
515 "numTriangleShapes",
516 ),
517 );
518 }
519 };
520 let m_vertexBase = match m_vertexBase {
521 _serde::__private::Some(__field) => __field,
522 _serde::__private::None => {
523 return _serde::__private::Err(
524 <__A::Error as _serde::de::Error>::missing_field(
525 "vertexBase",
526 ),
527 );
528 }
529 };
530 let m_numVertices = match m_numVertices {
531 _serde::__private::Some(__field) => __field,
532 _serde::__private::None => {
533 return _serde::__private::Err(
534 <__A::Error as _serde::de::Error>::missing_field(
535 "numVertices",
536 ),
537 );
538 }
539 };
540 let m_indexBase = match m_indexBase {
541 _serde::__private::Some(__field) => __field,
542 _serde::__private::None => {
543 return _serde::__private::Err(
544 <__A::Error as _serde::de::Error>::missing_field(
545 "indexBase",
546 ),
547 );
548 }
549 };
550 let m_vertexStriding = match m_vertexStriding {
551 _serde::__private::Some(__field) => __field,
552 _serde::__private::None => {
553 return _serde::__private::Err(
554 <__A::Error as _serde::de::Error>::missing_field(
555 "vertexStriding",
556 ),
557 );
558 }
559 };
560 let m_triangleOffset = match m_triangleOffset {
561 _serde::__private::Some(__field) => __field,
562 _serde::__private::None => {
563 return _serde::__private::Err(
564 <__A::Error as _serde::de::Error>::missing_field(
565 "triangleOffset",
566 ),
567 );
568 }
569 };
570 let m_indexStriding = match m_indexStriding {
571 _serde::__private::Some(__field) => __field,
572 _serde::__private::None => {
573 return _serde::__private::Err(
574 <__A::Error as _serde::de::Error>::missing_field(
575 "indexStriding",
576 ),
577 );
578 }
579 };
580 let m_stridingType = match m_stridingType {
581 _serde::__private::Some(__field) => __field,
582 _serde::__private::None => {
583 return _serde::__private::Err(
584 <__A::Error as _serde::de::Error>::missing_field(
585 "stridingType",
586 ),
587 );
588 }
589 };
590 let m_flipAlternateTriangles = match m_flipAlternateTriangles {
591 _serde::__private::Some(__field) => __field,
592 _serde::__private::None => {
593 return _serde::__private::Err(
594 <__A::Error as _serde::de::Error>::missing_field(
595 "flipAlternateTriangles",
596 ),
597 );
598 }
599 };
600 let m_extrusion = match m_extrusion {
601 _serde::__private::Some(__field) => __field,
602 _serde::__private::None => {
603 return _serde::__private::Err(
604 <__A::Error as _serde::de::Error>::missing_field(
605 "extrusion",
606 ),
607 );
608 }
609 };
610 let m_transform = match m_transform {
611 _serde::__private::Some(__field) => __field,
612 _serde::__private::None => {
613 return _serde::__private::Err(
614 <__A::Error as _serde::de::Error>::missing_field(
615 "transform",
616 ),
617 );
618 }
619 };
620 _serde::__private::Ok(hkpExtendedMeshShapeTrianglesSubpart {
621 __ptr,
622 parent,
623 m_numTriangleShapes,
624 m_vertexBase,
625 m_numVertices,
626 m_indexBase,
627 m_vertexStriding,
628 m_triangleOffset,
629 m_indexStriding,
630 m_stridingType,
631 m_flipAlternateTriangles,
632 m_extrusion,
633 m_transform,
634 })
635 }
636 #[allow(clippy::manual_unwrap_or_default)]
637 fn visit_struct<__A>(
638 self,
639 mut __map: __A,
640 ) -> _serde::__private::Result<Self::Value, __A::Error>
641 where
642 __A: _serde::de::MapAccess<'de>,
643 {
644 let mut m_type: _serde::__private::Option<SubpartType> = _serde::__private::None;
645 let mut m_materialIndexStridingType: _serde::__private::Option<
646 MaterialIndexStridingType,
647 > = _serde::__private::None;
648 let mut m_materialIndexStriding: _serde::__private::Option<u16> = _serde::__private::None;
649 let mut m_numMaterials: _serde::__private::Option<u16> = _serde::__private::None;
650 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
651 let mut m_numTriangleShapes: _serde::__private::Option<i32> = _serde::__private::None;
652 let mut m_numVertices: _serde::__private::Option<i32> = _serde::__private::None;
653 let mut m_vertexStriding: _serde::__private::Option<u16> = _serde::__private::None;
654 let mut m_triangleOffset: _serde::__private::Option<i32> = _serde::__private::None;
655 let mut m_indexStriding: _serde::__private::Option<u16> = _serde::__private::None;
656 let mut m_stridingType: _serde::__private::Option<
657 IndexStridingType,
658 > = _serde::__private::None;
659 let mut m_flipAlternateTriangles: _serde::__private::Option<i8> = _serde::__private::None;
660 let mut m_extrusion: _serde::__private::Option<Vector4> = _serde::__private::None;
661 let mut m_transform: _serde::__private::Option<QsTransform> = _serde::__private::None;
662 while let _serde::__private::Some(__key) = {
663 __A::next_key::<__Field>(&mut __map)?
664 } {
665 match __key {
666 __Field::m_type => {
667 #[cfg(
668 any(feature = "strict", feature = "ignore_duplicates")
669 )]
670 if _serde::__private::Option::is_some(&m_type) {
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("type"),
679 );
680 }
681 m_type = _serde::__private::Some(
682 match __A::next_value::<SubpartType>(&mut __map) {
683 _serde::__private::Ok(__val) => __val,
684 _serde::__private::Err(__err) => {
685 return _serde::__private::Err(__err);
686 }
687 },
688 );
689 }
690 __Field::m_materialIndexStridingType => {
691 #[cfg(
692 any(feature = "strict", feature = "ignore_duplicates")
693 )]
694 if _serde::__private::Option::is_some(
695 &m_materialIndexStridingType,
696 ) {
697 #[cfg(feature = "ignore_duplicates")]
698 {
699 __A::skip_value(&mut __map)?;
700 continue;
701 }
702 #[cfg(feature = "strict")]
703 return _serde::__private::Err(
704 <__A::Error as _serde::de::Error>::duplicate_field(
705 "materialIndexStridingType",
706 ),
707 );
708 }
709 m_materialIndexStridingType = _serde::__private::Some(
710 match __A::next_value::<
711 MaterialIndexStridingType,
712 >(&mut __map) {
713 _serde::__private::Ok(__val) => __val,
714 _serde::__private::Err(__err) => {
715 return _serde::__private::Err(__err);
716 }
717 },
718 );
719 }
720 __Field::m_materialIndexStriding => {
721 #[cfg(
722 any(feature = "strict", feature = "ignore_duplicates")
723 )]
724 if _serde::__private::Option::is_some(
725 &m_materialIndexStriding,
726 ) {
727 #[cfg(feature = "ignore_duplicates")]
728 {
729 __A::skip_value(&mut __map)?;
730 continue;
731 }
732 #[cfg(feature = "strict")]
733 return _serde::__private::Err(
734 <__A::Error as _serde::de::Error>::duplicate_field(
735 "materialIndexStriding",
736 ),
737 );
738 }
739 m_materialIndexStriding = _serde::__private::Some(
740 match __A::next_value::<u16>(&mut __map) {
741 _serde::__private::Ok(__val) => __val,
742 _serde::__private::Err(__err) => {
743 return _serde::__private::Err(__err);
744 }
745 },
746 );
747 }
748 __Field::m_numMaterials => {
749 #[cfg(
750 any(feature = "strict", feature = "ignore_duplicates")
751 )]
752 if _serde::__private::Option::is_some(&m_numMaterials) {
753 #[cfg(feature = "ignore_duplicates")]
754 {
755 __A::skip_value(&mut __map)?;
756 continue;
757 }
758 #[cfg(feature = "strict")]
759 return _serde::__private::Err(
760 <__A::Error as _serde::de::Error>::duplicate_field(
761 "numMaterials",
762 ),
763 );
764 }
765 m_numMaterials = _serde::__private::Some(
766 match __A::next_value::<u16>(&mut __map) {
767 _serde::__private::Ok(__val) => __val,
768 _serde::__private::Err(__err) => {
769 return _serde::__private::Err(__err);
770 }
771 },
772 );
773 }
774 __Field::m_userData => {
775 #[cfg(
776 any(feature = "strict", feature = "ignore_duplicates")
777 )]
778 if _serde::__private::Option::is_some(&m_userData) {
779 #[cfg(feature = "ignore_duplicates")]
780 {
781 __A::skip_value(&mut __map)?;
782 continue;
783 }
784 #[cfg(feature = "strict")]
785 return _serde::__private::Err(
786 <__A::Error as _serde::de::Error>::duplicate_field(
787 "userData",
788 ),
789 );
790 }
791 m_userData = _serde::__private::Some(
792 match __A::next_value::<Ulong>(&mut __map) {
793 _serde::__private::Ok(__val) => __val,
794 _serde::__private::Err(__err) => {
795 return _serde::__private::Err(__err);
796 }
797 },
798 );
799 }
800 __Field::m_numTriangleShapes => {
801 #[cfg(
802 any(feature = "strict", feature = "ignore_duplicates")
803 )]
804 if _serde::__private::Option::is_some(
805 &m_numTriangleShapes,
806 ) {
807 #[cfg(feature = "ignore_duplicates")]
808 {
809 __A::skip_value(&mut __map)?;
810 continue;
811 }
812 #[cfg(feature = "strict")]
813 return _serde::__private::Err(
814 <__A::Error as _serde::de::Error>::duplicate_field(
815 "numTriangleShapes",
816 ),
817 );
818 }
819 m_numTriangleShapes = _serde::__private::Some(
820 match __A::next_value::<i32>(&mut __map) {
821 _serde::__private::Ok(__val) => __val,
822 _serde::__private::Err(__err) => {
823 return _serde::__private::Err(__err);
824 }
825 },
826 );
827 }
828 __Field::m_numVertices => {
829 #[cfg(
830 any(feature = "strict", feature = "ignore_duplicates")
831 )]
832 if _serde::__private::Option::is_some(&m_numVertices) {
833 #[cfg(feature = "ignore_duplicates")]
834 {
835 __A::skip_value(&mut __map)?;
836 continue;
837 }
838 #[cfg(feature = "strict")]
839 return _serde::__private::Err(
840 <__A::Error as _serde::de::Error>::duplicate_field(
841 "numVertices",
842 ),
843 );
844 }
845 m_numVertices = _serde::__private::Some(
846 match __A::next_value::<i32>(&mut __map) {
847 _serde::__private::Ok(__val) => __val,
848 _serde::__private::Err(__err) => {
849 return _serde::__private::Err(__err);
850 }
851 },
852 );
853 }
854 __Field::m_vertexStriding => {
855 #[cfg(
856 any(feature = "strict", feature = "ignore_duplicates")
857 )]
858 if _serde::__private::Option::is_some(&m_vertexStriding) {
859 #[cfg(feature = "ignore_duplicates")]
860 {
861 __A::skip_value(&mut __map)?;
862 continue;
863 }
864 #[cfg(feature = "strict")]
865 return _serde::__private::Err(
866 <__A::Error as _serde::de::Error>::duplicate_field(
867 "vertexStriding",
868 ),
869 );
870 }
871 m_vertexStriding = _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 __Field::m_triangleOffset => {
881 #[cfg(
882 any(feature = "strict", feature = "ignore_duplicates")
883 )]
884 if _serde::__private::Option::is_some(&m_triangleOffset) {
885 #[cfg(feature = "ignore_duplicates")]
886 {
887 __A::skip_value(&mut __map)?;
888 continue;
889 }
890 #[cfg(feature = "strict")]
891 return _serde::__private::Err(
892 <__A::Error as _serde::de::Error>::duplicate_field(
893 "triangleOffset",
894 ),
895 );
896 }
897 m_triangleOffset = _serde::__private::Some(
898 match __A::next_value::<i32>(&mut __map) {
899 _serde::__private::Ok(__val) => __val,
900 _serde::__private::Err(__err) => {
901 return _serde::__private::Err(__err);
902 }
903 },
904 );
905 }
906 __Field::m_indexStriding => {
907 #[cfg(
908 any(feature = "strict", feature = "ignore_duplicates")
909 )]
910 if _serde::__private::Option::is_some(&m_indexStriding) {
911 #[cfg(feature = "ignore_duplicates")]
912 {
913 __A::skip_value(&mut __map)?;
914 continue;
915 }
916 #[cfg(feature = "strict")]
917 return _serde::__private::Err(
918 <__A::Error as _serde::de::Error>::duplicate_field(
919 "indexStriding",
920 ),
921 );
922 }
923 m_indexStriding = _serde::__private::Some(
924 match __A::next_value::<u16>(&mut __map) {
925 _serde::__private::Ok(__val) => __val,
926 _serde::__private::Err(__err) => {
927 return _serde::__private::Err(__err);
928 }
929 },
930 );
931 }
932 __Field::m_stridingType => {
933 #[cfg(
934 any(feature = "strict", feature = "ignore_duplicates")
935 )]
936 if _serde::__private::Option::is_some(&m_stridingType) {
937 #[cfg(feature = "ignore_duplicates")]
938 {
939 __A::skip_value(&mut __map)?;
940 continue;
941 }
942 #[cfg(feature = "strict")]
943 return _serde::__private::Err(
944 <__A::Error as _serde::de::Error>::duplicate_field(
945 "stridingType",
946 ),
947 );
948 }
949 m_stridingType = _serde::__private::Some(
950 match __A::next_value::<IndexStridingType>(&mut __map) {
951 _serde::__private::Ok(__val) => __val,
952 _serde::__private::Err(__err) => {
953 return _serde::__private::Err(__err);
954 }
955 },
956 );
957 }
958 __Field::m_flipAlternateTriangles => {
959 #[cfg(
960 any(feature = "strict", feature = "ignore_duplicates")
961 )]
962 if _serde::__private::Option::is_some(
963 &m_flipAlternateTriangles,
964 ) {
965 #[cfg(feature = "ignore_duplicates")]
966 {
967 __A::skip_value(&mut __map)?;
968 continue;
969 }
970 #[cfg(feature = "strict")]
971 return _serde::__private::Err(
972 <__A::Error as _serde::de::Error>::duplicate_field(
973 "flipAlternateTriangles",
974 ),
975 );
976 }
977 m_flipAlternateTriangles = _serde::__private::Some(
978 match __A::next_value::<i8>(&mut __map) {
979 _serde::__private::Ok(__val) => __val,
980 _serde::__private::Err(__err) => {
981 return _serde::__private::Err(__err);
982 }
983 },
984 );
985 }
986 __Field::m_extrusion => {
987 #[cfg(
988 any(feature = "strict", feature = "ignore_duplicates")
989 )]
990 if _serde::__private::Option::is_some(&m_extrusion) {
991 #[cfg(feature = "ignore_duplicates")]
992 {
993 __A::skip_value(&mut __map)?;
994 continue;
995 }
996 #[cfg(feature = "strict")]
997 return _serde::__private::Err(
998 <__A::Error as _serde::de::Error>::duplicate_field(
999 "extrusion",
1000 ),
1001 );
1002 }
1003 m_extrusion = _serde::__private::Some(
1004 match __A::next_value::<Vector4>(&mut __map) {
1005 _serde::__private::Ok(__val) => __val,
1006 _serde::__private::Err(__err) => {
1007 return _serde::__private::Err(__err);
1008 }
1009 },
1010 );
1011 }
1012 __Field::m_transform => {
1013 #[cfg(
1014 any(feature = "strict", feature = "ignore_duplicates")
1015 )]
1016 if _serde::__private::Option::is_some(&m_transform) {
1017 #[cfg(feature = "ignore_duplicates")]
1018 {
1019 __A::skip_value(&mut __map)?;
1020 continue;
1021 }
1022 #[cfg(feature = "strict")]
1023 return _serde::__private::Err(
1024 <__A::Error as _serde::de::Error>::duplicate_field(
1025 "transform",
1026 ),
1027 );
1028 }
1029 m_transform = _serde::__private::Some(
1030 match __A::next_value::<QsTransform>(&mut __map) {
1031 _serde::__private::Ok(__val) => __val,
1032 _serde::__private::Err(__err) => {
1033 return _serde::__private::Err(__err);
1034 }
1035 },
1036 );
1037 }
1038 _ => __A::skip_value(&mut __map)?,
1039 }
1040 }
1041 let m_type = match m_type {
1042 _serde::__private::Some(__field) => __field,
1043 _serde::__private::None => {
1044 #[cfg(feature = "strict")]
1045 return _serde::__private::Err(
1046 <__A::Error as _serde::de::Error>::missing_field("type"),
1047 );
1048 #[cfg(not(feature = "strict"))] Default::default()
1049 }
1050 };
1051 let m_materialIndexStridingType = match m_materialIndexStridingType {
1052 _serde::__private::Some(__field) => __field,
1053 _serde::__private::None => {
1054 #[cfg(feature = "strict")]
1055 return _serde::__private::Err(
1056 <__A::Error as _serde::de::Error>::missing_field(
1057 "materialIndexStridingType",
1058 ),
1059 );
1060 #[cfg(not(feature = "strict"))] Default::default()
1061 }
1062 };
1063 let m_materialIndexStriding = match m_materialIndexStriding {
1064 _serde::__private::Some(__field) => __field,
1065 _serde::__private::None => {
1066 #[cfg(feature = "strict")]
1067 return _serde::__private::Err(
1068 <__A::Error as _serde::de::Error>::missing_field(
1069 "materialIndexStriding",
1070 ),
1071 );
1072 #[cfg(not(feature = "strict"))] Default::default()
1073 }
1074 };
1075 let m_numMaterials = match m_numMaterials {
1076 _serde::__private::Some(__field) => __field,
1077 _serde::__private::None => {
1078 #[cfg(feature = "strict")]
1079 return _serde::__private::Err(
1080 <__A::Error as _serde::de::Error>::missing_field(
1081 "numMaterials",
1082 ),
1083 );
1084 #[cfg(not(feature = "strict"))] Default::default()
1085 }
1086 };
1087 let m_userData = match m_userData {
1088 _serde::__private::Some(__field) => __field,
1089 _serde::__private::None => {
1090 #[cfg(feature = "strict")]
1091 return _serde::__private::Err(
1092 <__A::Error as _serde::de::Error>::missing_field("userData"),
1093 );
1094 #[cfg(not(feature = "strict"))] Default::default()
1095 }
1096 };
1097 let m_numTriangleShapes = match m_numTriangleShapes {
1098 _serde::__private::Some(__field) => __field,
1099 _serde::__private::None => {
1100 #[cfg(feature = "strict")]
1101 return _serde::__private::Err(
1102 <__A::Error as _serde::de::Error>::missing_field(
1103 "numTriangleShapes",
1104 ),
1105 );
1106 #[cfg(not(feature = "strict"))] Default::default()
1107 }
1108 };
1109 let m_numVertices = match m_numVertices {
1110 _serde::__private::Some(__field) => __field,
1111 _serde::__private::None => {
1112 #[cfg(feature = "strict")]
1113 return _serde::__private::Err(
1114 <__A::Error as _serde::de::Error>::missing_field(
1115 "numVertices",
1116 ),
1117 );
1118 #[cfg(not(feature = "strict"))] Default::default()
1119 }
1120 };
1121 let m_vertexStriding = match m_vertexStriding {
1122 _serde::__private::Some(__field) => __field,
1123 _serde::__private::None => {
1124 #[cfg(feature = "strict")]
1125 return _serde::__private::Err(
1126 <__A::Error as _serde::de::Error>::missing_field(
1127 "vertexStriding",
1128 ),
1129 );
1130 #[cfg(not(feature = "strict"))] Default::default()
1131 }
1132 };
1133 let m_triangleOffset = match m_triangleOffset {
1134 _serde::__private::Some(__field) => __field,
1135 _serde::__private::None => {
1136 #[cfg(feature = "strict")]
1137 return _serde::__private::Err(
1138 <__A::Error as _serde::de::Error>::missing_field(
1139 "triangleOffset",
1140 ),
1141 );
1142 #[cfg(not(feature = "strict"))] Default::default()
1143 }
1144 };
1145 let m_indexStriding = match m_indexStriding {
1146 _serde::__private::Some(__field) => __field,
1147 _serde::__private::None => {
1148 #[cfg(feature = "strict")]
1149 return _serde::__private::Err(
1150 <__A::Error as _serde::de::Error>::missing_field(
1151 "indexStriding",
1152 ),
1153 );
1154 #[cfg(not(feature = "strict"))] Default::default()
1155 }
1156 };
1157 let m_stridingType = match m_stridingType {
1158 _serde::__private::Some(__field) => __field,
1159 _serde::__private::None => {
1160 #[cfg(feature = "strict")]
1161 return _serde::__private::Err(
1162 <__A::Error as _serde::de::Error>::missing_field(
1163 "stridingType",
1164 ),
1165 );
1166 #[cfg(not(feature = "strict"))] Default::default()
1167 }
1168 };
1169 let m_flipAlternateTriangles = match m_flipAlternateTriangles {
1170 _serde::__private::Some(__field) => __field,
1171 _serde::__private::None => {
1172 #[cfg(feature = "strict")]
1173 return _serde::__private::Err(
1174 <__A::Error as _serde::de::Error>::missing_field(
1175 "flipAlternateTriangles",
1176 ),
1177 );
1178 #[cfg(not(feature = "strict"))] Default::default()
1179 }
1180 };
1181 let m_extrusion = match m_extrusion {
1182 _serde::__private::Some(__field) => __field,
1183 _serde::__private::None => {
1184 #[cfg(feature = "strict")]
1185 return _serde::__private::Err(
1186 <__A::Error as _serde::de::Error>::missing_field(
1187 "extrusion",
1188 ),
1189 );
1190 #[cfg(not(feature = "strict"))] Default::default()
1191 }
1192 };
1193 let m_transform = match m_transform {
1194 _serde::__private::Some(__field) => __field,
1195 _serde::__private::None => {
1196 #[cfg(feature = "strict")]
1197 return _serde::__private::Err(
1198 <__A::Error as _serde::de::Error>::missing_field(
1199 "transform",
1200 ),
1201 );
1202 #[cfg(not(feature = "strict"))] Default::default()
1203 }
1204 };
1205 let __ptr = None;
1206 let parent = hkpExtendedMeshShapeSubpart {
1207 __ptr,
1208 m_type,
1209 m_materialIndexStridingType,
1210 m_materialIndexStriding,
1211 m_numMaterials,
1212 m_userData,
1213 ..Default::default()
1214 };
1215 let __ptr = __A::class_ptr(&mut __map);
1216 _serde::__private::Ok(hkpExtendedMeshShapeTrianglesSubpart {
1217 __ptr,
1218 parent,
1219 m_numTriangleShapes,
1220 m_numVertices,
1221 m_vertexStriding,
1222 m_triangleOffset,
1223 m_indexStriding,
1224 m_stridingType,
1225 m_flipAlternateTriangles,
1226 m_extrusion,
1227 m_transform,
1228 ..Default::default()
1229 })
1230 }
1231 }
1232 const FIELDS: &[&str] = &[
1233 "numTriangleShapes",
1234 "vertexBase",
1235 "numVertices",
1236 "indexBase",
1237 "vertexStriding",
1238 "triangleOffset",
1239 "indexStriding",
1240 "stridingType",
1241 "flipAlternateTriangles",
1242 "extrusion",
1243 "transform",
1244 ];
1245 _serde::Deserializer::deserialize_struct(
1246 deserializer,
1247 "hkpExtendedMeshShapeTrianglesSubpart",
1248 FIELDS,
1249 __hkpExtendedMeshShapeTrianglesSubpartVisitor {
1250 marker: _serde::__private::PhantomData::<
1251 hkpExtendedMeshShapeTrianglesSubpart,
1252 >,
1253 lifetime: _serde::__private::PhantomData,
1254 },
1255 )
1256 }
1257 }
1258};