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