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 hkpCylinderShape {
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 = "cylRadius"))]
35 #[cfg_attr(feature = "serde", serde(rename = "cylRadius"))]
36 pub m_cylRadius: f32,
37 #[cfg_attr(
42 feature = "json_schema",
43 schemars(rename = "cylBaseRadiusFactorForHeightFieldCollisions")
44 )]
45 #[cfg_attr(
46 feature = "serde",
47 serde(rename = "cylBaseRadiusFactorForHeightFieldCollisions")
48 )]
49 pub m_cylBaseRadiusFactorForHeightFieldCollisions: f32,
50 #[cfg_attr(feature = "json_schema", schemars(rename = "vertexA"))]
55 #[cfg_attr(feature = "serde", serde(rename = "vertexA"))]
56 pub m_vertexA: Vector4,
57 #[cfg_attr(feature = "json_schema", schemars(rename = "vertexB"))]
62 #[cfg_attr(feature = "serde", serde(rename = "vertexB"))]
63 pub m_vertexB: Vector4,
64 #[cfg_attr(feature = "json_schema", schemars(rename = "perpendicular1"))]
69 #[cfg_attr(feature = "serde", serde(rename = "perpendicular1"))]
70 pub m_perpendicular1: Vector4,
71 #[cfg_attr(feature = "json_schema", schemars(rename = "perpendicular2"))]
76 #[cfg_attr(feature = "serde", serde(rename = "perpendicular2"))]
77 pub m_perpendicular2: Vector4,
78}
79const _: () = {
80 use havok_serde as _serde;
81 impl _serde::HavokClass for hkpCylinderShape {
82 #[inline]
83 fn name(&self) -> &'static str {
84 "hkpCylinderShape"
85 }
86 #[inline]
87 fn signature(&self) -> _serde::__private::Signature {
88 _serde::__private::Signature::new(0x3e463c3a)
89 }
90 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
91 fn deps_indexes(&self) -> Vec<usize> {
92 let mut v = Vec::new();
93 v
94 }
95 }
96 impl _serde::Serialize for hkpCylinderShape {
97 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
98 where
99 S: _serde::ser::Serializer,
100 {
101 let class_meta = self
102 .__ptr
103 .map(|name| (name, _serde::__private::Signature::new(0x3e463c3a)));
104 let mut serializer = __serializer
105 .serialize_struct("hkpCylinderShape", class_meta, (96u64, 112u64))?;
106 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
107 serializer
108 .skip_field(
109 "memSizeAndFlags",
110 &self.parent.parent.parent.parent.m_memSizeAndFlags,
111 )?;
112 serializer
113 .skip_field(
114 "referenceCount",
115 &self.parent.parent.parent.parent.m_referenceCount,
116 )?;
117 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
118 serializer
119 .serialize_field("userData", &self.parent.parent.parent.m_userData)?;
120 serializer.skip_field("type", &self.parent.parent.parent.m_type)?;
121 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
122 serializer.serialize_field("radius", &self.parent.m_radius)?;
123 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
124 serializer.serialize_field("cylRadius", &self.m_cylRadius)?;
125 serializer
126 .serialize_field(
127 "cylBaseRadiusFactorForHeightFieldCollisions",
128 &self.m_cylBaseRadiusFactorForHeightFieldCollisions,
129 )?;
130 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
131 serializer.serialize_field("vertexA", &self.m_vertexA)?;
132 serializer.serialize_field("vertexB", &self.m_vertexB)?;
133 serializer.serialize_field("perpendicular1", &self.m_perpendicular1)?;
134 serializer.serialize_field("perpendicular2", &self.m_perpendicular2)?;
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 hkpCylinderShape {
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_userData,
152 m_radius,
153 m_cylRadius,
154 m_cylBaseRadiusFactorForHeightFieldCollisions,
155 m_vertexA,
156 m_vertexB,
157 m_perpendicular1,
158 m_perpendicular2,
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 "userData" => Ok(__Field::m_userData),
183 "radius" => Ok(__Field::m_radius),
184 "cylRadius" => Ok(__Field::m_cylRadius),
185 "cylBaseRadiusFactorForHeightFieldCollisions" => {
186 Ok(__Field::m_cylBaseRadiusFactorForHeightFieldCollisions)
187 }
188 "vertexA" => Ok(__Field::m_vertexA),
189 "vertexB" => Ok(__Field::m_vertexB),
190 "perpendicular1" => Ok(__Field::m_perpendicular1),
191 "perpendicular2" => Ok(__Field::m_perpendicular2),
192 _ => Ok(__Field::__ignore),
193 }
194 }
195 }
196 impl<'de> _serde::Deserialize<'de> for __Field {
197 #[inline]
198 fn deserialize<__D>(
199 __deserializer: __D,
200 ) -> core::result::Result<Self, __D::Error>
201 where
202 __D: _serde::Deserializer<'de>,
203 {
204 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
205 }
206 }
207 struct __hkpCylinderShapeVisitor<'de> {
208 marker: _serde::__private::PhantomData<hkpCylinderShape>,
209 lifetime: _serde::__private::PhantomData<&'de ()>,
210 }
211 #[allow(clippy::match_single_binding)]
212 #[allow(clippy::reversed_empty_ranges)]
213 #[allow(clippy::single_match)]
214 impl<'de> _serde::de::Visitor<'de> for __hkpCylinderShapeVisitor<'de> {
215 type Value = hkpCylinderShape;
216 fn expecting(
217 &self,
218 __formatter: &mut core::fmt::Formatter,
219 ) -> core::fmt::Result {
220 core::fmt::Formatter::write_str(
221 __formatter,
222 "struct hkpCylinderShape",
223 )
224 }
225 fn visit_struct_for_bytes<__A>(
226 self,
227 mut __map: __A,
228 ) -> _serde::__private::Result<Self::Value, __A::Error>
229 where
230 __A: _serde::de::MapAccess<'de>,
231 {
232 let __ptr = __A::class_ptr(&mut __map);
233 let parent = __A::parent_value(&mut __map)?;
234 let mut m_cylRadius: _serde::__private::Option<f32> = _serde::__private::None;
235 let mut m_cylBaseRadiusFactorForHeightFieldCollisions: _serde::__private::Option<
236 f32,
237 > = _serde::__private::None;
238 let mut m_vertexA: _serde::__private::Option<Vector4> = _serde::__private::None;
239 let mut m_vertexB: _serde::__private::Option<Vector4> = _serde::__private::None;
240 let mut m_perpendicular1: _serde::__private::Option<Vector4> = _serde::__private::None;
241 let mut m_perpendicular2: _serde::__private::Option<Vector4> = _serde::__private::None;
242 for i in 0..6usize {
243 match i {
244 0usize => {
245 if _serde::__private::Option::is_some(&m_cylRadius) {
246 return _serde::__private::Err(
247 <__A::Error as _serde::de::Error>::duplicate_field(
248 "cylRadius",
249 ),
250 );
251 }
252 m_cylRadius = _serde::__private::Some(
253 match __A::next_value::<f32>(&mut __map) {
254 _serde::__private::Ok(__val) => __val,
255 _serde::__private::Err(__err) => {
256 return _serde::__private::Err(__err);
257 }
258 },
259 );
260 }
261 1usize => {
262 if _serde::__private::Option::is_some(
263 &m_cylBaseRadiusFactorForHeightFieldCollisions,
264 ) {
265 return _serde::__private::Err(
266 <__A::Error as _serde::de::Error>::duplicate_field(
267 "cylBaseRadiusFactorForHeightFieldCollisions",
268 ),
269 );
270 }
271 m_cylBaseRadiusFactorForHeightFieldCollisions = _serde::__private::Some(
272 match __A::next_value::<f32>(&mut __map) {
273 _serde::__private::Ok(__val) => __val,
274 _serde::__private::Err(__err) => {
275 return _serde::__private::Err(__err);
276 }
277 },
278 );
279 }
280 2usize => {
281 if _serde::__private::Option::is_some(&m_vertexA) {
282 return _serde::__private::Err(
283 <__A::Error as _serde::de::Error>::duplicate_field(
284 "vertexA",
285 ),
286 );
287 }
288 __A::pad(&mut __map, 4usize, 0usize)?;
289 m_vertexA = _serde::__private::Some(
290 match __A::next_value::<Vector4>(&mut __map) {
291 _serde::__private::Ok(__val) => __val,
292 _serde::__private::Err(__err) => {
293 return _serde::__private::Err(__err);
294 }
295 },
296 );
297 }
298 3usize => {
299 if _serde::__private::Option::is_some(&m_vertexB) {
300 return _serde::__private::Err(
301 <__A::Error as _serde::de::Error>::duplicate_field(
302 "vertexB",
303 ),
304 );
305 }
306 m_vertexB = _serde::__private::Some(
307 match __A::next_value::<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 4usize => {
316 if _serde::__private::Option::is_some(&m_perpendicular1) {
317 return _serde::__private::Err(
318 <__A::Error as _serde::de::Error>::duplicate_field(
319 "perpendicular1",
320 ),
321 );
322 }
323 m_perpendicular1 = _serde::__private::Some(
324 match __A::next_value::<Vector4>(&mut __map) {
325 _serde::__private::Ok(__val) => __val,
326 _serde::__private::Err(__err) => {
327 return _serde::__private::Err(__err);
328 }
329 },
330 );
331 }
332 5usize => {
333 if _serde::__private::Option::is_some(&m_perpendicular2) {
334 return _serde::__private::Err(
335 <__A::Error as _serde::de::Error>::duplicate_field(
336 "perpendicular2",
337 ),
338 );
339 }
340 m_perpendicular2 = _serde::__private::Some(
341 match __A::next_value::<Vector4>(&mut __map) {
342 _serde::__private::Ok(__val) => __val,
343 _serde::__private::Err(__err) => {
344 return _serde::__private::Err(__err);
345 }
346 },
347 );
348 }
349 _ => {}
350 }
351 }
352 let m_cylRadius = match m_cylRadius {
353 _serde::__private::Some(__field) => __field,
354 _serde::__private::None => {
355 return _serde::__private::Err(
356 <__A::Error as _serde::de::Error>::missing_field(
357 "cylRadius",
358 ),
359 );
360 }
361 };
362 let m_cylBaseRadiusFactorForHeightFieldCollisions = match m_cylBaseRadiusFactorForHeightFieldCollisions {
363 _serde::__private::Some(__field) => __field,
364 _serde::__private::None => {
365 return _serde::__private::Err(
366 <__A::Error as _serde::de::Error>::missing_field(
367 "cylBaseRadiusFactorForHeightFieldCollisions",
368 ),
369 );
370 }
371 };
372 let m_vertexA = match m_vertexA {
373 _serde::__private::Some(__field) => __field,
374 _serde::__private::None => {
375 return _serde::__private::Err(
376 <__A::Error as _serde::de::Error>::missing_field("vertexA"),
377 );
378 }
379 };
380 let m_vertexB = match m_vertexB {
381 _serde::__private::Some(__field) => __field,
382 _serde::__private::None => {
383 return _serde::__private::Err(
384 <__A::Error as _serde::de::Error>::missing_field("vertexB"),
385 );
386 }
387 };
388 let m_perpendicular1 = match m_perpendicular1 {
389 _serde::__private::Some(__field) => __field,
390 _serde::__private::None => {
391 return _serde::__private::Err(
392 <__A::Error as _serde::de::Error>::missing_field(
393 "perpendicular1",
394 ),
395 );
396 }
397 };
398 let m_perpendicular2 = match m_perpendicular2 {
399 _serde::__private::Some(__field) => __field,
400 _serde::__private::None => {
401 return _serde::__private::Err(
402 <__A::Error as _serde::de::Error>::missing_field(
403 "perpendicular2",
404 ),
405 );
406 }
407 };
408 _serde::__private::Ok(hkpCylinderShape {
409 __ptr,
410 parent,
411 m_cylRadius,
412 m_cylBaseRadiusFactorForHeightFieldCollisions,
413 m_vertexA,
414 m_vertexB,
415 m_perpendicular1,
416 m_perpendicular2,
417 })
418 }
419 #[allow(clippy::manual_unwrap_or_default)]
420 fn visit_struct<__A>(
421 self,
422 mut __map: __A,
423 ) -> _serde::__private::Result<Self::Value, __A::Error>
424 where
425 __A: _serde::de::MapAccess<'de>,
426 {
427 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
428 let mut m_radius: _serde::__private::Option<f32> = _serde::__private::None;
429 let mut m_cylRadius: _serde::__private::Option<f32> = _serde::__private::None;
430 let mut m_cylBaseRadiusFactorForHeightFieldCollisions: _serde::__private::Option<
431 f32,
432 > = _serde::__private::None;
433 let mut m_vertexA: _serde::__private::Option<Vector4> = _serde::__private::None;
434 let mut m_vertexB: _serde::__private::Option<Vector4> = _serde::__private::None;
435 let mut m_perpendicular1: _serde::__private::Option<Vector4> = _serde::__private::None;
436 let mut m_perpendicular2: _serde::__private::Option<Vector4> = _serde::__private::None;
437 while let _serde::__private::Some(__key) = {
438 __A::next_key::<__Field>(&mut __map)?
439 } {
440 match __key {
441 __Field::m_userData => {
442 #[cfg(
443 any(feature = "strict", feature = "ignore_duplicates")
444 )]
445 if _serde::__private::Option::is_some(&m_userData) {
446 #[cfg(feature = "ignore_duplicates")]
447 {
448 __A::skip_value(&mut __map)?;
449 continue;
450 }
451 #[cfg(feature = "strict")]
452 return _serde::__private::Err(
453 <__A::Error as _serde::de::Error>::duplicate_field(
454 "userData",
455 ),
456 );
457 }
458 m_userData = _serde::__private::Some(
459 match __A::next_value::<Ulong>(&mut __map) {
460 _serde::__private::Ok(__val) => __val,
461 _serde::__private::Err(__err) => {
462 return _serde::__private::Err(__err);
463 }
464 },
465 );
466 }
467 __Field::m_radius => {
468 #[cfg(
469 any(feature = "strict", feature = "ignore_duplicates")
470 )]
471 if _serde::__private::Option::is_some(&m_radius) {
472 #[cfg(feature = "ignore_duplicates")]
473 {
474 __A::skip_value(&mut __map)?;
475 continue;
476 }
477 #[cfg(feature = "strict")]
478 return _serde::__private::Err(
479 <__A::Error as _serde::de::Error>::duplicate_field("radius"),
480 );
481 }
482 m_radius = _serde::__private::Some(
483 match __A::next_value::<f32>(&mut __map) {
484 _serde::__private::Ok(__val) => __val,
485 _serde::__private::Err(__err) => {
486 return _serde::__private::Err(__err);
487 }
488 },
489 );
490 }
491 __Field::m_cylRadius => {
492 #[cfg(
493 any(feature = "strict", feature = "ignore_duplicates")
494 )]
495 if _serde::__private::Option::is_some(&m_cylRadius) {
496 #[cfg(feature = "ignore_duplicates")]
497 {
498 __A::skip_value(&mut __map)?;
499 continue;
500 }
501 #[cfg(feature = "strict")]
502 return _serde::__private::Err(
503 <__A::Error as _serde::de::Error>::duplicate_field(
504 "cylRadius",
505 ),
506 );
507 }
508 m_cylRadius = _serde::__private::Some(
509 match __A::next_value::<f32>(&mut __map) {
510 _serde::__private::Ok(__val) => __val,
511 _serde::__private::Err(__err) => {
512 return _serde::__private::Err(__err);
513 }
514 },
515 );
516 }
517 __Field::m_cylBaseRadiusFactorForHeightFieldCollisions => {
518 #[cfg(
519 any(feature = "strict", feature = "ignore_duplicates")
520 )]
521 if _serde::__private::Option::is_some(
522 &m_cylBaseRadiusFactorForHeightFieldCollisions,
523 ) {
524 #[cfg(feature = "ignore_duplicates")]
525 {
526 __A::skip_value(&mut __map)?;
527 continue;
528 }
529 #[cfg(feature = "strict")]
530 return _serde::__private::Err(
531 <__A::Error as _serde::de::Error>::duplicate_field(
532 "cylBaseRadiusFactorForHeightFieldCollisions",
533 ),
534 );
535 }
536 m_cylBaseRadiusFactorForHeightFieldCollisions = _serde::__private::Some(
537 match __A::next_value::<f32>(&mut __map) {
538 _serde::__private::Ok(__val) => __val,
539 _serde::__private::Err(__err) => {
540 return _serde::__private::Err(__err);
541 }
542 },
543 );
544 }
545 __Field::m_vertexA => {
546 #[cfg(
547 any(feature = "strict", feature = "ignore_duplicates")
548 )]
549 if _serde::__private::Option::is_some(&m_vertexA) {
550 #[cfg(feature = "ignore_duplicates")]
551 {
552 __A::skip_value(&mut __map)?;
553 continue;
554 }
555 #[cfg(feature = "strict")]
556 return _serde::__private::Err(
557 <__A::Error as _serde::de::Error>::duplicate_field(
558 "vertexA",
559 ),
560 );
561 }
562 m_vertexA = _serde::__private::Some(
563 match __A::next_value::<Vector4>(&mut __map) {
564 _serde::__private::Ok(__val) => __val,
565 _serde::__private::Err(__err) => {
566 return _serde::__private::Err(__err);
567 }
568 },
569 );
570 }
571 __Field::m_vertexB => {
572 #[cfg(
573 any(feature = "strict", feature = "ignore_duplicates")
574 )]
575 if _serde::__private::Option::is_some(&m_vertexB) {
576 #[cfg(feature = "ignore_duplicates")]
577 {
578 __A::skip_value(&mut __map)?;
579 continue;
580 }
581 #[cfg(feature = "strict")]
582 return _serde::__private::Err(
583 <__A::Error as _serde::de::Error>::duplicate_field(
584 "vertexB",
585 ),
586 );
587 }
588 m_vertexB = _serde::__private::Some(
589 match __A::next_value::<Vector4>(&mut __map) {
590 _serde::__private::Ok(__val) => __val,
591 _serde::__private::Err(__err) => {
592 return _serde::__private::Err(__err);
593 }
594 },
595 );
596 }
597 __Field::m_perpendicular1 => {
598 #[cfg(
599 any(feature = "strict", feature = "ignore_duplicates")
600 )]
601 if _serde::__private::Option::is_some(&m_perpendicular1) {
602 #[cfg(feature = "ignore_duplicates")]
603 {
604 __A::skip_value(&mut __map)?;
605 continue;
606 }
607 #[cfg(feature = "strict")]
608 return _serde::__private::Err(
609 <__A::Error as _serde::de::Error>::duplicate_field(
610 "perpendicular1",
611 ),
612 );
613 }
614 m_perpendicular1 = _serde::__private::Some(
615 match __A::next_value::<Vector4>(&mut __map) {
616 _serde::__private::Ok(__val) => __val,
617 _serde::__private::Err(__err) => {
618 return _serde::__private::Err(__err);
619 }
620 },
621 );
622 }
623 __Field::m_perpendicular2 => {
624 #[cfg(
625 any(feature = "strict", feature = "ignore_duplicates")
626 )]
627 if _serde::__private::Option::is_some(&m_perpendicular2) {
628 #[cfg(feature = "ignore_duplicates")]
629 {
630 __A::skip_value(&mut __map)?;
631 continue;
632 }
633 #[cfg(feature = "strict")]
634 return _serde::__private::Err(
635 <__A::Error as _serde::de::Error>::duplicate_field(
636 "perpendicular2",
637 ),
638 );
639 }
640 m_perpendicular2 = _serde::__private::Some(
641 match __A::next_value::<Vector4>(&mut __map) {
642 _serde::__private::Ok(__val) => __val,
643 _serde::__private::Err(__err) => {
644 return _serde::__private::Err(__err);
645 }
646 },
647 );
648 }
649 _ => __A::skip_value(&mut __map)?,
650 }
651 }
652 let m_userData = match m_userData {
653 _serde::__private::Some(__field) => __field,
654 _serde::__private::None => {
655 #[cfg(feature = "strict")]
656 return _serde::__private::Err(
657 <__A::Error as _serde::de::Error>::missing_field("userData"),
658 );
659 #[cfg(not(feature = "strict"))] Default::default()
660 }
661 };
662 let m_radius = match m_radius {
663 _serde::__private::Some(__field) => __field,
664 _serde::__private::None => {
665 #[cfg(feature = "strict")]
666 return _serde::__private::Err(
667 <__A::Error as _serde::de::Error>::missing_field("radius"),
668 );
669 #[cfg(not(feature = "strict"))] Default::default()
670 }
671 };
672 let m_cylRadius = match m_cylRadius {
673 _serde::__private::Some(__field) => __field,
674 _serde::__private::None => {
675 #[cfg(feature = "strict")]
676 return _serde::__private::Err(
677 <__A::Error as _serde::de::Error>::missing_field(
678 "cylRadius",
679 ),
680 );
681 #[cfg(not(feature = "strict"))] Default::default()
682 }
683 };
684 let m_cylBaseRadiusFactorForHeightFieldCollisions = match m_cylBaseRadiusFactorForHeightFieldCollisions {
685 _serde::__private::Some(__field) => __field,
686 _serde::__private::None => {
687 #[cfg(feature = "strict")]
688 return _serde::__private::Err(
689 <__A::Error as _serde::de::Error>::missing_field(
690 "cylBaseRadiusFactorForHeightFieldCollisions",
691 ),
692 );
693 #[cfg(not(feature = "strict"))] Default::default()
694 }
695 };
696 let m_vertexA = match m_vertexA {
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("vertexA"),
702 );
703 #[cfg(not(feature = "strict"))] Default::default()
704 }
705 };
706 let m_vertexB = match m_vertexB {
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("vertexB"),
712 );
713 #[cfg(not(feature = "strict"))] Default::default()
714 }
715 };
716 let m_perpendicular1 = match m_perpendicular1 {
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 "perpendicular1",
723 ),
724 );
725 #[cfg(not(feature = "strict"))] Default::default()
726 }
727 };
728 let m_perpendicular2 = match m_perpendicular2 {
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 "perpendicular2",
735 ),
736 );
737 #[cfg(not(feature = "strict"))] Default::default()
738 }
739 };
740 let __ptr = None;
741 let parent = hkBaseObject { __ptr };
742 let parent = hkReferencedObject {
743 __ptr,
744 parent,
745 ..Default::default()
746 };
747 let parent = hkpShape {
748 __ptr,
749 parent,
750 m_userData,
751 ..Default::default()
752 };
753 let parent = hkpSphereRepShape { __ptr, parent };
754 let parent = hkpConvexShape {
755 __ptr,
756 parent,
757 m_radius,
758 };
759 let __ptr = __A::class_ptr(&mut __map);
760 _serde::__private::Ok(hkpCylinderShape {
761 __ptr,
762 parent,
763 m_cylRadius,
764 m_cylBaseRadiusFactorForHeightFieldCollisions,
765 m_vertexA,
766 m_vertexB,
767 m_perpendicular1,
768 m_perpendicular2,
769 })
770 }
771 }
772 const FIELDS: &[&str] = &[
773 "cylRadius",
774 "cylBaseRadiusFactorForHeightFieldCollisions",
775 "vertexA",
776 "vertexB",
777 "perpendicular1",
778 "perpendicular2",
779 ];
780 _serde::Deserializer::deserialize_struct(
781 deserializer,
782 "hkpCylinderShape",
783 FIELDS,
784 __hkpCylinderShapeVisitor {
785 marker: _serde::__private::PhantomData::<hkpCylinderShape>,
786 lifetime: _serde::__private::PhantomData,
787 },
788 )
789 }
790 }
791};