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 hkpCharacterProxyCinfo {
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: hkpCharacterControllerCinfo,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "position"))]
35 #[cfg_attr(feature = "serde", serde(rename = "position"))]
36 pub m_position: Vector4,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "velocity"))]
42 #[cfg_attr(feature = "serde", serde(rename = "velocity"))]
43 pub m_velocity: Vector4,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "dynamicFriction"))]
49 #[cfg_attr(feature = "serde", serde(rename = "dynamicFriction"))]
50 pub m_dynamicFriction: f32,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "staticFriction"))]
56 #[cfg_attr(feature = "serde", serde(rename = "staticFriction"))]
57 pub m_staticFriction: f32,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "keepContactTolerance"))]
63 #[cfg_attr(feature = "serde", serde(rename = "keepContactTolerance"))]
64 pub m_keepContactTolerance: f32,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "up"))]
70 #[cfg_attr(feature = "serde", serde(rename = "up"))]
71 pub m_up: Vector4,
72 #[cfg_attr(feature = "json_schema", schemars(rename = "extraUpStaticFriction"))]
77 #[cfg_attr(feature = "serde", serde(rename = "extraUpStaticFriction"))]
78 pub m_extraUpStaticFriction: f32,
79 #[cfg_attr(feature = "json_schema", schemars(rename = "extraDownStaticFriction"))]
84 #[cfg_attr(feature = "serde", serde(rename = "extraDownStaticFriction"))]
85 pub m_extraDownStaticFriction: f32,
86 #[cfg_attr(feature = "json_schema", schemars(rename = "shapePhantom"))]
91 #[cfg_attr(feature = "serde", serde(rename = "shapePhantom"))]
92 pub m_shapePhantom: Pointer,
93 #[cfg_attr(feature = "json_schema", schemars(rename = "keepDistance"))]
98 #[cfg_attr(feature = "serde", serde(rename = "keepDistance"))]
99 pub m_keepDistance: f32,
100 #[cfg_attr(feature = "json_schema", schemars(rename = "contactAngleSensitivity"))]
105 #[cfg_attr(feature = "serde", serde(rename = "contactAngleSensitivity"))]
106 pub m_contactAngleSensitivity: f32,
107 #[cfg_attr(feature = "json_schema", schemars(rename = "userPlanes"))]
112 #[cfg_attr(feature = "serde", serde(rename = "userPlanes"))]
113 pub m_userPlanes: u32,
114 #[cfg_attr(feature = "json_schema", schemars(rename = "maxCharacterSpeedForSolver"))]
119 #[cfg_attr(feature = "serde", serde(rename = "maxCharacterSpeedForSolver"))]
120 pub m_maxCharacterSpeedForSolver: f32,
121 #[cfg_attr(feature = "json_schema", schemars(rename = "characterStrength"))]
126 #[cfg_attr(feature = "serde", serde(rename = "characterStrength"))]
127 pub m_characterStrength: f32,
128 #[cfg_attr(feature = "json_schema", schemars(rename = "characterMass"))]
133 #[cfg_attr(feature = "serde", serde(rename = "characterMass"))]
134 pub m_characterMass: f32,
135 #[cfg_attr(feature = "json_schema", schemars(rename = "maxSlope"))]
140 #[cfg_attr(feature = "serde", serde(rename = "maxSlope"))]
141 pub m_maxSlope: f32,
142 #[cfg_attr(feature = "json_schema", schemars(rename = "penetrationRecoverySpeed"))]
147 #[cfg_attr(feature = "serde", serde(rename = "penetrationRecoverySpeed"))]
148 pub m_penetrationRecoverySpeed: f32,
149 #[cfg_attr(feature = "json_schema", schemars(rename = "maxCastIterations"))]
154 #[cfg_attr(feature = "serde", serde(rename = "maxCastIterations"))]
155 pub m_maxCastIterations: i32,
156 #[cfg_attr(
161 feature = "json_schema",
162 schemars(rename = "refreshManifoldInCheckSupport")
163 )]
164 #[cfg_attr(feature = "serde", serde(rename = "refreshManifoldInCheckSupport"))]
165 pub m_refreshManifoldInCheckSupport: bool,
166}
167const _: () = {
168 use havok_serde as _serde;
169 impl _serde::HavokClass for hkpCharacterProxyCinfo {
170 #[inline]
171 fn name(&self) -> &'static str {
172 "hkpCharacterProxyCinfo"
173 }
174 #[inline]
175 fn signature(&self) -> _serde::__private::Signature {
176 _serde::__private::Signature::new(0x586d97b2)
177 }
178 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
179 fn deps_indexes(&self) -> Vec<usize> {
180 let mut v = Vec::new();
181 v.push(self.m_shapePhantom.get());
182 v
183 }
184 }
185 impl _serde::Serialize for hkpCharacterProxyCinfo {
186 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
187 where
188 S: _serde::ser::Serializer,
189 {
190 let class_meta = self
191 .__ptr
192 .map(|name| (name, _serde::__private::Signature::new(0x586d97b2)));
193 let mut serializer = __serializer
194 .serialize_struct(
195 "hkpCharacterProxyCinfo",
196 class_meta,
197 (144u64, 144u64),
198 )?;
199 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
200 serializer
201 .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
202 serializer
203 .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
204 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
205 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
206 serializer.serialize_field("position", &self.m_position)?;
207 serializer.serialize_field("velocity", &self.m_velocity)?;
208 serializer.serialize_field("dynamicFriction", &self.m_dynamicFriction)?;
209 serializer.serialize_field("staticFriction", &self.m_staticFriction)?;
210 serializer
211 .serialize_field("keepContactTolerance", &self.m_keepContactTolerance)?;
212 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 4usize].as_slice())?;
213 serializer.serialize_field("up", &self.m_up)?;
214 serializer
215 .serialize_field(
216 "extraUpStaticFriction",
217 &self.m_extraUpStaticFriction,
218 )?;
219 serializer
220 .serialize_field(
221 "extraDownStaticFriction",
222 &self.m_extraDownStaticFriction,
223 )?;
224 serializer.serialize_field("shapePhantom", &self.m_shapePhantom)?;
225 serializer.serialize_field("keepDistance", &self.m_keepDistance)?;
226 serializer
227 .serialize_field(
228 "contactAngleSensitivity",
229 &self.m_contactAngleSensitivity,
230 )?;
231 serializer.serialize_field("userPlanes", &self.m_userPlanes)?;
232 serializer
233 .serialize_field(
234 "maxCharacterSpeedForSolver",
235 &self.m_maxCharacterSpeedForSolver,
236 )?;
237 serializer.serialize_field("characterStrength", &self.m_characterStrength)?;
238 serializer.serialize_field("characterMass", &self.m_characterMass)?;
239 serializer.serialize_field("maxSlope", &self.m_maxSlope)?;
240 serializer
241 .serialize_field(
242 "penetrationRecoverySpeed",
243 &self.m_penetrationRecoverySpeed,
244 )?;
245 serializer.serialize_field("maxCastIterations", &self.m_maxCastIterations)?;
246 serializer
247 .serialize_field(
248 "refreshManifoldInCheckSupport",
249 &self.m_refreshManifoldInCheckSupport,
250 )?;
251 serializer.pad_field([0u8; 15usize].as_slice(), [0u8; 11usize].as_slice())?;
252 serializer.end()
253 }
254 }
255};
256#[doc(hidden)]
257#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
258const _: () = {
259 use havok_serde as _serde;
260 #[automatically_derived]
261 impl<'de> _serde::Deserialize<'de> for hkpCharacterProxyCinfo {
262 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
263 where
264 __D: _serde::Deserializer<'de>,
265 {
266 #[allow(non_camel_case_types)]
267 enum __Field {
268 m_position,
269 m_velocity,
270 m_dynamicFriction,
271 m_staticFriction,
272 m_keepContactTolerance,
273 m_up,
274 m_extraUpStaticFriction,
275 m_extraDownStaticFriction,
276 m_shapePhantom,
277 m_keepDistance,
278 m_contactAngleSensitivity,
279 m_userPlanes,
280 m_maxCharacterSpeedForSolver,
281 m_characterStrength,
282 m_characterMass,
283 m_maxSlope,
284 m_penetrationRecoverySpeed,
285 m_maxCastIterations,
286 m_refreshManifoldInCheckSupport,
287 __ignore,
288 }
289 struct __FieldVisitor;
290 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
291 type Value = __Field;
292 fn expecting(
293 &self,
294 __formatter: &mut core::fmt::Formatter,
295 ) -> core::fmt::Result {
296 core::fmt::Formatter::write_str(__formatter, "field identifier")
297 }
298 #[allow(clippy::match_single_binding)]
300 #[allow(clippy::reversed_empty_ranges)]
301 #[allow(clippy::single_match)]
302 fn visit_key<__E>(
303 self,
304 __value: &str,
305 ) -> core::result::Result<Self::Value, __E>
306 where
307 __E: _serde::de::Error,
308 {
309 match __value {
310 "position" => Ok(__Field::m_position),
311 "velocity" => Ok(__Field::m_velocity),
312 "dynamicFriction" => Ok(__Field::m_dynamicFriction),
313 "staticFriction" => Ok(__Field::m_staticFriction),
314 "keepContactTolerance" => Ok(__Field::m_keepContactTolerance),
315 "up" => Ok(__Field::m_up),
316 "extraUpStaticFriction" => Ok(__Field::m_extraUpStaticFriction),
317 "extraDownStaticFriction" => {
318 Ok(__Field::m_extraDownStaticFriction)
319 }
320 "shapePhantom" => Ok(__Field::m_shapePhantom),
321 "keepDistance" => Ok(__Field::m_keepDistance),
322 "contactAngleSensitivity" => {
323 Ok(__Field::m_contactAngleSensitivity)
324 }
325 "userPlanes" => Ok(__Field::m_userPlanes),
326 "maxCharacterSpeedForSolver" => {
327 Ok(__Field::m_maxCharacterSpeedForSolver)
328 }
329 "characterStrength" => Ok(__Field::m_characterStrength),
330 "characterMass" => Ok(__Field::m_characterMass),
331 "maxSlope" => Ok(__Field::m_maxSlope),
332 "penetrationRecoverySpeed" => {
333 Ok(__Field::m_penetrationRecoverySpeed)
334 }
335 "maxCastIterations" => Ok(__Field::m_maxCastIterations),
336 "refreshManifoldInCheckSupport" => {
337 Ok(__Field::m_refreshManifoldInCheckSupport)
338 }
339 _ => Ok(__Field::__ignore),
340 }
341 }
342 }
343 impl<'de> _serde::Deserialize<'de> for __Field {
344 #[inline]
345 fn deserialize<__D>(
346 __deserializer: __D,
347 ) -> core::result::Result<Self, __D::Error>
348 where
349 __D: _serde::Deserializer<'de>,
350 {
351 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
352 }
353 }
354 struct __hkpCharacterProxyCinfoVisitor<'de> {
355 marker: _serde::__private::PhantomData<hkpCharacterProxyCinfo>,
356 lifetime: _serde::__private::PhantomData<&'de ()>,
357 }
358 #[allow(clippy::match_single_binding)]
359 #[allow(clippy::reversed_empty_ranges)]
360 #[allow(clippy::single_match)]
361 impl<'de> _serde::de::Visitor<'de> for __hkpCharacterProxyCinfoVisitor<'de> {
362 type Value = hkpCharacterProxyCinfo;
363 fn expecting(
364 &self,
365 __formatter: &mut core::fmt::Formatter,
366 ) -> core::fmt::Result {
367 core::fmt::Formatter::write_str(
368 __formatter,
369 "struct hkpCharacterProxyCinfo",
370 )
371 }
372 fn visit_struct_for_bytes<__A>(
373 self,
374 mut __map: __A,
375 ) -> _serde::__private::Result<Self::Value, __A::Error>
376 where
377 __A: _serde::de::MapAccess<'de>,
378 {
379 let __ptr = __A::class_ptr(&mut __map);
380 let parent = __A::parent_value(&mut __map)?;
381 let mut m_position: _serde::__private::Option<Vector4> = _serde::__private::None;
382 let mut m_velocity: _serde::__private::Option<Vector4> = _serde::__private::None;
383 let mut m_dynamicFriction: _serde::__private::Option<f32> = _serde::__private::None;
384 let mut m_staticFriction: _serde::__private::Option<f32> = _serde::__private::None;
385 let mut m_keepContactTolerance: _serde::__private::Option<f32> = _serde::__private::None;
386 let mut m_up: _serde::__private::Option<Vector4> = _serde::__private::None;
387 let mut m_extraUpStaticFriction: _serde::__private::Option<f32> = _serde::__private::None;
388 let mut m_extraDownStaticFriction: _serde::__private::Option<f32> = _serde::__private::None;
389 let mut m_shapePhantom: _serde::__private::Option<Pointer> = _serde::__private::None;
390 let mut m_keepDistance: _serde::__private::Option<f32> = _serde::__private::None;
391 let mut m_contactAngleSensitivity: _serde::__private::Option<f32> = _serde::__private::None;
392 let mut m_userPlanes: _serde::__private::Option<u32> = _serde::__private::None;
393 let mut m_maxCharacterSpeedForSolver: _serde::__private::Option<
394 f32,
395 > = _serde::__private::None;
396 let mut m_characterStrength: _serde::__private::Option<f32> = _serde::__private::None;
397 let mut m_characterMass: _serde::__private::Option<f32> = _serde::__private::None;
398 let mut m_maxSlope: _serde::__private::Option<f32> = _serde::__private::None;
399 let mut m_penetrationRecoverySpeed: _serde::__private::Option<f32> = _serde::__private::None;
400 let mut m_maxCastIterations: _serde::__private::Option<i32> = _serde::__private::None;
401 let mut m_refreshManifoldInCheckSupport: _serde::__private::Option<
402 bool,
403 > = _serde::__private::None;
404 for i in 0..19usize {
405 match i {
406 0usize => {
407 if _serde::__private::Option::is_some(&m_position) {
408 return _serde::__private::Err(
409 <__A::Error as _serde::de::Error>::duplicate_field(
410 "position",
411 ),
412 );
413 }
414 __A::pad(&mut __map, 8usize, 0usize)?;
415 m_position = _serde::__private::Some(
416 match __A::next_value::<Vector4>(&mut __map) {
417 _serde::__private::Ok(__val) => __val,
418 _serde::__private::Err(__err) => {
419 return _serde::__private::Err(__err);
420 }
421 },
422 );
423 }
424 1usize => {
425 if _serde::__private::Option::is_some(&m_velocity) {
426 return _serde::__private::Err(
427 <__A::Error as _serde::de::Error>::duplicate_field(
428 "velocity",
429 ),
430 );
431 }
432 m_velocity = _serde::__private::Some(
433 match __A::next_value::<Vector4>(&mut __map) {
434 _serde::__private::Ok(__val) => __val,
435 _serde::__private::Err(__err) => {
436 return _serde::__private::Err(__err);
437 }
438 },
439 );
440 }
441 2usize => {
442 if _serde::__private::Option::is_some(&m_dynamicFriction) {
443 return _serde::__private::Err(
444 <__A::Error as _serde::de::Error>::duplicate_field(
445 "dynamicFriction",
446 ),
447 );
448 }
449 m_dynamicFriction = _serde::__private::Some(
450 match __A::next_value::<f32>(&mut __map) {
451 _serde::__private::Ok(__val) => __val,
452 _serde::__private::Err(__err) => {
453 return _serde::__private::Err(__err);
454 }
455 },
456 );
457 }
458 3usize => {
459 if _serde::__private::Option::is_some(&m_staticFriction) {
460 return _serde::__private::Err(
461 <__A::Error as _serde::de::Error>::duplicate_field(
462 "staticFriction",
463 ),
464 );
465 }
466 m_staticFriction = _serde::__private::Some(
467 match __A::next_value::<f32>(&mut __map) {
468 _serde::__private::Ok(__val) => __val,
469 _serde::__private::Err(__err) => {
470 return _serde::__private::Err(__err);
471 }
472 },
473 );
474 }
475 4usize => {
476 if _serde::__private::Option::is_some(
477 &m_keepContactTolerance,
478 ) {
479 return _serde::__private::Err(
480 <__A::Error as _serde::de::Error>::duplicate_field(
481 "keepContactTolerance",
482 ),
483 );
484 }
485 m_keepContactTolerance = _serde::__private::Some(
486 match __A::next_value::<f32>(&mut __map) {
487 _serde::__private::Ok(__val) => __val,
488 _serde::__private::Err(__err) => {
489 return _serde::__private::Err(__err);
490 }
491 },
492 );
493 }
494 5usize => {
495 if _serde::__private::Option::is_some(&m_up) {
496 return _serde::__private::Err(
497 <__A::Error as _serde::de::Error>::duplicate_field("up"),
498 );
499 }
500 __A::pad(&mut __map, 4usize, 4usize)?;
501 m_up = _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 6usize => {
511 if _serde::__private::Option::is_some(
512 &m_extraUpStaticFriction,
513 ) {
514 return _serde::__private::Err(
515 <__A::Error as _serde::de::Error>::duplicate_field(
516 "extraUpStaticFriction",
517 ),
518 );
519 }
520 m_extraUpStaticFriction = _serde::__private::Some(
521 match __A::next_value::<f32>(&mut __map) {
522 _serde::__private::Ok(__val) => __val,
523 _serde::__private::Err(__err) => {
524 return _serde::__private::Err(__err);
525 }
526 },
527 );
528 }
529 7usize => {
530 if _serde::__private::Option::is_some(
531 &m_extraDownStaticFriction,
532 ) {
533 return _serde::__private::Err(
534 <__A::Error as _serde::de::Error>::duplicate_field(
535 "extraDownStaticFriction",
536 ),
537 );
538 }
539 m_extraDownStaticFriction = _serde::__private::Some(
540 match __A::next_value::<f32>(&mut __map) {
541 _serde::__private::Ok(__val) => __val,
542 _serde::__private::Err(__err) => {
543 return _serde::__private::Err(__err);
544 }
545 },
546 );
547 }
548 8usize => {
549 if _serde::__private::Option::is_some(&m_shapePhantom) {
550 return _serde::__private::Err(
551 <__A::Error as _serde::de::Error>::duplicate_field(
552 "shapePhantom",
553 ),
554 );
555 }
556 m_shapePhantom = _serde::__private::Some(
557 match __A::next_value::<Pointer>(&mut __map) {
558 _serde::__private::Ok(__val) => __val,
559 _serde::__private::Err(__err) => {
560 return _serde::__private::Err(__err);
561 }
562 },
563 );
564 }
565 9usize => {
566 if _serde::__private::Option::is_some(&m_keepDistance) {
567 return _serde::__private::Err(
568 <__A::Error as _serde::de::Error>::duplicate_field(
569 "keepDistance",
570 ),
571 );
572 }
573 m_keepDistance = _serde::__private::Some(
574 match __A::next_value::<f32>(&mut __map) {
575 _serde::__private::Ok(__val) => __val,
576 _serde::__private::Err(__err) => {
577 return _serde::__private::Err(__err);
578 }
579 },
580 );
581 }
582 10usize => {
583 if _serde::__private::Option::is_some(
584 &m_contactAngleSensitivity,
585 ) {
586 return _serde::__private::Err(
587 <__A::Error as _serde::de::Error>::duplicate_field(
588 "contactAngleSensitivity",
589 ),
590 );
591 }
592 m_contactAngleSensitivity = _serde::__private::Some(
593 match __A::next_value::<f32>(&mut __map) {
594 _serde::__private::Ok(__val) => __val,
595 _serde::__private::Err(__err) => {
596 return _serde::__private::Err(__err);
597 }
598 },
599 );
600 }
601 11usize => {
602 if _serde::__private::Option::is_some(&m_userPlanes) {
603 return _serde::__private::Err(
604 <__A::Error as _serde::de::Error>::duplicate_field(
605 "userPlanes",
606 ),
607 );
608 }
609 m_userPlanes = _serde::__private::Some(
610 match __A::next_value::<u32>(&mut __map) {
611 _serde::__private::Ok(__val) => __val,
612 _serde::__private::Err(__err) => {
613 return _serde::__private::Err(__err);
614 }
615 },
616 );
617 }
618 12usize => {
619 if _serde::__private::Option::is_some(
620 &m_maxCharacterSpeedForSolver,
621 ) {
622 return _serde::__private::Err(
623 <__A::Error as _serde::de::Error>::duplicate_field(
624 "maxCharacterSpeedForSolver",
625 ),
626 );
627 }
628 m_maxCharacterSpeedForSolver = _serde::__private::Some(
629 match __A::next_value::<f32>(&mut __map) {
630 _serde::__private::Ok(__val) => __val,
631 _serde::__private::Err(__err) => {
632 return _serde::__private::Err(__err);
633 }
634 },
635 );
636 }
637 13usize => {
638 if _serde::__private::Option::is_some(
639 &m_characterStrength,
640 ) {
641 return _serde::__private::Err(
642 <__A::Error as _serde::de::Error>::duplicate_field(
643 "characterStrength",
644 ),
645 );
646 }
647 m_characterStrength = _serde::__private::Some(
648 match __A::next_value::<f32>(&mut __map) {
649 _serde::__private::Ok(__val) => __val,
650 _serde::__private::Err(__err) => {
651 return _serde::__private::Err(__err);
652 }
653 },
654 );
655 }
656 14usize => {
657 if _serde::__private::Option::is_some(&m_characterMass) {
658 return _serde::__private::Err(
659 <__A::Error as _serde::de::Error>::duplicate_field(
660 "characterMass",
661 ),
662 );
663 }
664 m_characterMass = _serde::__private::Some(
665 match __A::next_value::<f32>(&mut __map) {
666 _serde::__private::Ok(__val) => __val,
667 _serde::__private::Err(__err) => {
668 return _serde::__private::Err(__err);
669 }
670 },
671 );
672 }
673 15usize => {
674 if _serde::__private::Option::is_some(&m_maxSlope) {
675 return _serde::__private::Err(
676 <__A::Error as _serde::de::Error>::duplicate_field(
677 "maxSlope",
678 ),
679 );
680 }
681 m_maxSlope = _serde::__private::Some(
682 match __A::next_value::<f32>(&mut __map) {
683 _serde::__private::Ok(__val) => __val,
684 _serde::__private::Err(__err) => {
685 return _serde::__private::Err(__err);
686 }
687 },
688 );
689 }
690 16usize => {
691 if _serde::__private::Option::is_some(
692 &m_penetrationRecoverySpeed,
693 ) {
694 return _serde::__private::Err(
695 <__A::Error as _serde::de::Error>::duplicate_field(
696 "penetrationRecoverySpeed",
697 ),
698 );
699 }
700 m_penetrationRecoverySpeed = _serde::__private::Some(
701 match __A::next_value::<f32>(&mut __map) {
702 _serde::__private::Ok(__val) => __val,
703 _serde::__private::Err(__err) => {
704 return _serde::__private::Err(__err);
705 }
706 },
707 );
708 }
709 17usize => {
710 if _serde::__private::Option::is_some(
711 &m_maxCastIterations,
712 ) {
713 return _serde::__private::Err(
714 <__A::Error as _serde::de::Error>::duplicate_field(
715 "maxCastIterations",
716 ),
717 );
718 }
719 m_maxCastIterations = _serde::__private::Some(
720 match __A::next_value::<i32>(&mut __map) {
721 _serde::__private::Ok(__val) => __val,
722 _serde::__private::Err(__err) => {
723 return _serde::__private::Err(__err);
724 }
725 },
726 );
727 }
728 18usize => {
729 if _serde::__private::Option::is_some(
730 &m_refreshManifoldInCheckSupport,
731 ) {
732 return _serde::__private::Err(
733 <__A::Error as _serde::de::Error>::duplicate_field(
734 "refreshManifoldInCheckSupport",
735 ),
736 );
737 }
738 m_refreshManifoldInCheckSupport = _serde::__private::Some(
739 match __A::next_value::<bool>(&mut __map) {
740 _serde::__private::Ok(__val) => __val,
741 _serde::__private::Err(__err) => {
742 return _serde::__private::Err(__err);
743 }
744 },
745 );
746 }
747 _ => {}
748 }
749 }
750 __A::pad(&mut __map, 15usize, 11usize)?;
751 let m_position = match m_position {
752 _serde::__private::Some(__field) => __field,
753 _serde::__private::None => {
754 return _serde::__private::Err(
755 <__A::Error as _serde::de::Error>::missing_field("position"),
756 );
757 }
758 };
759 let m_velocity = match m_velocity {
760 _serde::__private::Some(__field) => __field,
761 _serde::__private::None => {
762 return _serde::__private::Err(
763 <__A::Error as _serde::de::Error>::missing_field("velocity"),
764 );
765 }
766 };
767 let m_dynamicFriction = match m_dynamicFriction {
768 _serde::__private::Some(__field) => __field,
769 _serde::__private::None => {
770 return _serde::__private::Err(
771 <__A::Error as _serde::de::Error>::missing_field(
772 "dynamicFriction",
773 ),
774 );
775 }
776 };
777 let m_staticFriction = match m_staticFriction {
778 _serde::__private::Some(__field) => __field,
779 _serde::__private::None => {
780 return _serde::__private::Err(
781 <__A::Error as _serde::de::Error>::missing_field(
782 "staticFriction",
783 ),
784 );
785 }
786 };
787 let m_keepContactTolerance = match m_keepContactTolerance {
788 _serde::__private::Some(__field) => __field,
789 _serde::__private::None => {
790 return _serde::__private::Err(
791 <__A::Error as _serde::de::Error>::missing_field(
792 "keepContactTolerance",
793 ),
794 );
795 }
796 };
797 let m_up = match m_up {
798 _serde::__private::Some(__field) => __field,
799 _serde::__private::None => {
800 return _serde::__private::Err(
801 <__A::Error as _serde::de::Error>::missing_field("up"),
802 );
803 }
804 };
805 let m_extraUpStaticFriction = match m_extraUpStaticFriction {
806 _serde::__private::Some(__field) => __field,
807 _serde::__private::None => {
808 return _serde::__private::Err(
809 <__A::Error as _serde::de::Error>::missing_field(
810 "extraUpStaticFriction",
811 ),
812 );
813 }
814 };
815 let m_extraDownStaticFriction = match m_extraDownStaticFriction {
816 _serde::__private::Some(__field) => __field,
817 _serde::__private::None => {
818 return _serde::__private::Err(
819 <__A::Error as _serde::de::Error>::missing_field(
820 "extraDownStaticFriction",
821 ),
822 );
823 }
824 };
825 let m_shapePhantom = match m_shapePhantom {
826 _serde::__private::Some(__field) => __field,
827 _serde::__private::None => {
828 return _serde::__private::Err(
829 <__A::Error as _serde::de::Error>::missing_field(
830 "shapePhantom",
831 ),
832 );
833 }
834 };
835 let m_keepDistance = match m_keepDistance {
836 _serde::__private::Some(__field) => __field,
837 _serde::__private::None => {
838 return _serde::__private::Err(
839 <__A::Error as _serde::de::Error>::missing_field(
840 "keepDistance",
841 ),
842 );
843 }
844 };
845 let m_contactAngleSensitivity = match m_contactAngleSensitivity {
846 _serde::__private::Some(__field) => __field,
847 _serde::__private::None => {
848 return _serde::__private::Err(
849 <__A::Error as _serde::de::Error>::missing_field(
850 "contactAngleSensitivity",
851 ),
852 );
853 }
854 };
855 let m_userPlanes = match m_userPlanes {
856 _serde::__private::Some(__field) => __field,
857 _serde::__private::None => {
858 return _serde::__private::Err(
859 <__A::Error as _serde::de::Error>::missing_field(
860 "userPlanes",
861 ),
862 );
863 }
864 };
865 let m_maxCharacterSpeedForSolver = match m_maxCharacterSpeedForSolver {
866 _serde::__private::Some(__field) => __field,
867 _serde::__private::None => {
868 return _serde::__private::Err(
869 <__A::Error as _serde::de::Error>::missing_field(
870 "maxCharacterSpeedForSolver",
871 ),
872 );
873 }
874 };
875 let m_characterStrength = match m_characterStrength {
876 _serde::__private::Some(__field) => __field,
877 _serde::__private::None => {
878 return _serde::__private::Err(
879 <__A::Error as _serde::de::Error>::missing_field(
880 "characterStrength",
881 ),
882 );
883 }
884 };
885 let m_characterMass = match m_characterMass {
886 _serde::__private::Some(__field) => __field,
887 _serde::__private::None => {
888 return _serde::__private::Err(
889 <__A::Error as _serde::de::Error>::missing_field(
890 "characterMass",
891 ),
892 );
893 }
894 };
895 let m_maxSlope = match m_maxSlope {
896 _serde::__private::Some(__field) => __field,
897 _serde::__private::None => {
898 return _serde::__private::Err(
899 <__A::Error as _serde::de::Error>::missing_field("maxSlope"),
900 );
901 }
902 };
903 let m_penetrationRecoverySpeed = match m_penetrationRecoverySpeed {
904 _serde::__private::Some(__field) => __field,
905 _serde::__private::None => {
906 return _serde::__private::Err(
907 <__A::Error as _serde::de::Error>::missing_field(
908 "penetrationRecoverySpeed",
909 ),
910 );
911 }
912 };
913 let m_maxCastIterations = match m_maxCastIterations {
914 _serde::__private::Some(__field) => __field,
915 _serde::__private::None => {
916 return _serde::__private::Err(
917 <__A::Error as _serde::de::Error>::missing_field(
918 "maxCastIterations",
919 ),
920 );
921 }
922 };
923 let m_refreshManifoldInCheckSupport = match m_refreshManifoldInCheckSupport {
924 _serde::__private::Some(__field) => __field,
925 _serde::__private::None => {
926 return _serde::__private::Err(
927 <__A::Error as _serde::de::Error>::missing_field(
928 "refreshManifoldInCheckSupport",
929 ),
930 );
931 }
932 };
933 _serde::__private::Ok(hkpCharacterProxyCinfo {
934 __ptr,
935 parent,
936 m_position,
937 m_velocity,
938 m_dynamicFriction,
939 m_staticFriction,
940 m_keepContactTolerance,
941 m_up,
942 m_extraUpStaticFriction,
943 m_extraDownStaticFriction,
944 m_shapePhantom,
945 m_keepDistance,
946 m_contactAngleSensitivity,
947 m_userPlanes,
948 m_maxCharacterSpeedForSolver,
949 m_characterStrength,
950 m_characterMass,
951 m_maxSlope,
952 m_penetrationRecoverySpeed,
953 m_maxCastIterations,
954 m_refreshManifoldInCheckSupport,
955 })
956 }
957 #[allow(clippy::manual_unwrap_or_default)]
958 fn visit_struct<__A>(
959 self,
960 mut __map: __A,
961 ) -> _serde::__private::Result<Self::Value, __A::Error>
962 where
963 __A: _serde::de::MapAccess<'de>,
964 {
965 let mut m_position: _serde::__private::Option<Vector4> = _serde::__private::None;
966 let mut m_velocity: _serde::__private::Option<Vector4> = _serde::__private::None;
967 let mut m_dynamicFriction: _serde::__private::Option<f32> = _serde::__private::None;
968 let mut m_staticFriction: _serde::__private::Option<f32> = _serde::__private::None;
969 let mut m_keepContactTolerance: _serde::__private::Option<f32> = _serde::__private::None;
970 let mut m_up: _serde::__private::Option<Vector4> = _serde::__private::None;
971 let mut m_extraUpStaticFriction: _serde::__private::Option<f32> = _serde::__private::None;
972 let mut m_extraDownStaticFriction: _serde::__private::Option<f32> = _serde::__private::None;
973 let mut m_shapePhantom: _serde::__private::Option<Pointer> = _serde::__private::None;
974 let mut m_keepDistance: _serde::__private::Option<f32> = _serde::__private::None;
975 let mut m_contactAngleSensitivity: _serde::__private::Option<f32> = _serde::__private::None;
976 let mut m_userPlanes: _serde::__private::Option<u32> = _serde::__private::None;
977 let mut m_maxCharacterSpeedForSolver: _serde::__private::Option<
978 f32,
979 > = _serde::__private::None;
980 let mut m_characterStrength: _serde::__private::Option<f32> = _serde::__private::None;
981 let mut m_characterMass: _serde::__private::Option<f32> = _serde::__private::None;
982 let mut m_maxSlope: _serde::__private::Option<f32> = _serde::__private::None;
983 let mut m_penetrationRecoverySpeed: _serde::__private::Option<f32> = _serde::__private::None;
984 let mut m_maxCastIterations: _serde::__private::Option<i32> = _serde::__private::None;
985 let mut m_refreshManifoldInCheckSupport: _serde::__private::Option<
986 bool,
987 > = _serde::__private::None;
988 while let _serde::__private::Some(__key) = {
989 __A::next_key::<__Field>(&mut __map)?
990 } {
991 match __key {
992 __Field::m_position => {
993 #[cfg(
994 any(feature = "strict", feature = "ignore_duplicates")
995 )]
996 if _serde::__private::Option::is_some(&m_position) {
997 #[cfg(feature = "ignore_duplicates")]
998 {
999 __A::skip_value(&mut __map)?;
1000 continue;
1001 }
1002 #[cfg(feature = "strict")]
1003 return _serde::__private::Err(
1004 <__A::Error as _serde::de::Error>::duplicate_field(
1005 "position",
1006 ),
1007 );
1008 }
1009 m_position = _serde::__private::Some(
1010 match __A::next_value::<Vector4>(&mut __map) {
1011 _serde::__private::Ok(__val) => __val,
1012 _serde::__private::Err(__err) => {
1013 return _serde::__private::Err(__err);
1014 }
1015 },
1016 );
1017 }
1018 __Field::m_velocity => {
1019 #[cfg(
1020 any(feature = "strict", feature = "ignore_duplicates")
1021 )]
1022 if _serde::__private::Option::is_some(&m_velocity) {
1023 #[cfg(feature = "ignore_duplicates")]
1024 {
1025 __A::skip_value(&mut __map)?;
1026 continue;
1027 }
1028 #[cfg(feature = "strict")]
1029 return _serde::__private::Err(
1030 <__A::Error as _serde::de::Error>::duplicate_field(
1031 "velocity",
1032 ),
1033 );
1034 }
1035 m_velocity = _serde::__private::Some(
1036 match __A::next_value::<Vector4>(&mut __map) {
1037 _serde::__private::Ok(__val) => __val,
1038 _serde::__private::Err(__err) => {
1039 return _serde::__private::Err(__err);
1040 }
1041 },
1042 );
1043 }
1044 __Field::m_dynamicFriction => {
1045 #[cfg(
1046 any(feature = "strict", feature = "ignore_duplicates")
1047 )]
1048 if _serde::__private::Option::is_some(&m_dynamicFriction) {
1049 #[cfg(feature = "ignore_duplicates")]
1050 {
1051 __A::skip_value(&mut __map)?;
1052 continue;
1053 }
1054 #[cfg(feature = "strict")]
1055 return _serde::__private::Err(
1056 <__A::Error as _serde::de::Error>::duplicate_field(
1057 "dynamicFriction",
1058 ),
1059 );
1060 }
1061 m_dynamicFriction = _serde::__private::Some(
1062 match __A::next_value::<f32>(&mut __map) {
1063 _serde::__private::Ok(__val) => __val,
1064 _serde::__private::Err(__err) => {
1065 return _serde::__private::Err(__err);
1066 }
1067 },
1068 );
1069 }
1070 __Field::m_staticFriction => {
1071 #[cfg(
1072 any(feature = "strict", feature = "ignore_duplicates")
1073 )]
1074 if _serde::__private::Option::is_some(&m_staticFriction) {
1075 #[cfg(feature = "ignore_duplicates")]
1076 {
1077 __A::skip_value(&mut __map)?;
1078 continue;
1079 }
1080 #[cfg(feature = "strict")]
1081 return _serde::__private::Err(
1082 <__A::Error as _serde::de::Error>::duplicate_field(
1083 "staticFriction",
1084 ),
1085 );
1086 }
1087 m_staticFriction = _serde::__private::Some(
1088 match __A::next_value::<f32>(&mut __map) {
1089 _serde::__private::Ok(__val) => __val,
1090 _serde::__private::Err(__err) => {
1091 return _serde::__private::Err(__err);
1092 }
1093 },
1094 );
1095 }
1096 __Field::m_keepContactTolerance => {
1097 #[cfg(
1098 any(feature = "strict", feature = "ignore_duplicates")
1099 )]
1100 if _serde::__private::Option::is_some(
1101 &m_keepContactTolerance,
1102 ) {
1103 #[cfg(feature = "ignore_duplicates")]
1104 {
1105 __A::skip_value(&mut __map)?;
1106 continue;
1107 }
1108 #[cfg(feature = "strict")]
1109 return _serde::__private::Err(
1110 <__A::Error as _serde::de::Error>::duplicate_field(
1111 "keepContactTolerance",
1112 ),
1113 );
1114 }
1115 m_keepContactTolerance = _serde::__private::Some(
1116 match __A::next_value::<f32>(&mut __map) {
1117 _serde::__private::Ok(__val) => __val,
1118 _serde::__private::Err(__err) => {
1119 return _serde::__private::Err(__err);
1120 }
1121 },
1122 );
1123 }
1124 __Field::m_up => {
1125 #[cfg(
1126 any(feature = "strict", feature = "ignore_duplicates")
1127 )]
1128 if _serde::__private::Option::is_some(&m_up) {
1129 #[cfg(feature = "ignore_duplicates")]
1130 {
1131 __A::skip_value(&mut __map)?;
1132 continue;
1133 }
1134 #[cfg(feature = "strict")]
1135 return _serde::__private::Err(
1136 <__A::Error as _serde::de::Error>::duplicate_field("up"),
1137 );
1138 }
1139 m_up = _serde::__private::Some(
1140 match __A::next_value::<Vector4>(&mut __map) {
1141 _serde::__private::Ok(__val) => __val,
1142 _serde::__private::Err(__err) => {
1143 return _serde::__private::Err(__err);
1144 }
1145 },
1146 );
1147 }
1148 __Field::m_extraUpStaticFriction => {
1149 #[cfg(
1150 any(feature = "strict", feature = "ignore_duplicates")
1151 )]
1152 if _serde::__private::Option::is_some(
1153 &m_extraUpStaticFriction,
1154 ) {
1155 #[cfg(feature = "ignore_duplicates")]
1156 {
1157 __A::skip_value(&mut __map)?;
1158 continue;
1159 }
1160 #[cfg(feature = "strict")]
1161 return _serde::__private::Err(
1162 <__A::Error as _serde::de::Error>::duplicate_field(
1163 "extraUpStaticFriction",
1164 ),
1165 );
1166 }
1167 m_extraUpStaticFriction = _serde::__private::Some(
1168 match __A::next_value::<f32>(&mut __map) {
1169 _serde::__private::Ok(__val) => __val,
1170 _serde::__private::Err(__err) => {
1171 return _serde::__private::Err(__err);
1172 }
1173 },
1174 );
1175 }
1176 __Field::m_extraDownStaticFriction => {
1177 #[cfg(
1178 any(feature = "strict", feature = "ignore_duplicates")
1179 )]
1180 if _serde::__private::Option::is_some(
1181 &m_extraDownStaticFriction,
1182 ) {
1183 #[cfg(feature = "ignore_duplicates")]
1184 {
1185 __A::skip_value(&mut __map)?;
1186 continue;
1187 }
1188 #[cfg(feature = "strict")]
1189 return _serde::__private::Err(
1190 <__A::Error as _serde::de::Error>::duplicate_field(
1191 "extraDownStaticFriction",
1192 ),
1193 );
1194 }
1195 m_extraDownStaticFriction = _serde::__private::Some(
1196 match __A::next_value::<f32>(&mut __map) {
1197 _serde::__private::Ok(__val) => __val,
1198 _serde::__private::Err(__err) => {
1199 return _serde::__private::Err(__err);
1200 }
1201 },
1202 );
1203 }
1204 __Field::m_shapePhantom => {
1205 #[cfg(
1206 any(feature = "strict", feature = "ignore_duplicates")
1207 )]
1208 if _serde::__private::Option::is_some(&m_shapePhantom) {
1209 #[cfg(feature = "ignore_duplicates")]
1210 {
1211 __A::skip_value(&mut __map)?;
1212 continue;
1213 }
1214 #[cfg(feature = "strict")]
1215 return _serde::__private::Err(
1216 <__A::Error as _serde::de::Error>::duplicate_field(
1217 "shapePhantom",
1218 ),
1219 );
1220 }
1221 m_shapePhantom = _serde::__private::Some(
1222 match __A::next_value::<Pointer>(&mut __map) {
1223 _serde::__private::Ok(__val) => __val,
1224 _serde::__private::Err(__err) => {
1225 return _serde::__private::Err(__err);
1226 }
1227 },
1228 );
1229 }
1230 __Field::m_keepDistance => {
1231 #[cfg(
1232 any(feature = "strict", feature = "ignore_duplicates")
1233 )]
1234 if _serde::__private::Option::is_some(&m_keepDistance) {
1235 #[cfg(feature = "ignore_duplicates")]
1236 {
1237 __A::skip_value(&mut __map)?;
1238 continue;
1239 }
1240 #[cfg(feature = "strict")]
1241 return _serde::__private::Err(
1242 <__A::Error as _serde::de::Error>::duplicate_field(
1243 "keepDistance",
1244 ),
1245 );
1246 }
1247 m_keepDistance = _serde::__private::Some(
1248 match __A::next_value::<f32>(&mut __map) {
1249 _serde::__private::Ok(__val) => __val,
1250 _serde::__private::Err(__err) => {
1251 return _serde::__private::Err(__err);
1252 }
1253 },
1254 );
1255 }
1256 __Field::m_contactAngleSensitivity => {
1257 #[cfg(
1258 any(feature = "strict", feature = "ignore_duplicates")
1259 )]
1260 if _serde::__private::Option::is_some(
1261 &m_contactAngleSensitivity,
1262 ) {
1263 #[cfg(feature = "ignore_duplicates")]
1264 {
1265 __A::skip_value(&mut __map)?;
1266 continue;
1267 }
1268 #[cfg(feature = "strict")]
1269 return _serde::__private::Err(
1270 <__A::Error as _serde::de::Error>::duplicate_field(
1271 "contactAngleSensitivity",
1272 ),
1273 );
1274 }
1275 m_contactAngleSensitivity = _serde::__private::Some(
1276 match __A::next_value::<f32>(&mut __map) {
1277 _serde::__private::Ok(__val) => __val,
1278 _serde::__private::Err(__err) => {
1279 return _serde::__private::Err(__err);
1280 }
1281 },
1282 );
1283 }
1284 __Field::m_userPlanes => {
1285 #[cfg(
1286 any(feature = "strict", feature = "ignore_duplicates")
1287 )]
1288 if _serde::__private::Option::is_some(&m_userPlanes) {
1289 #[cfg(feature = "ignore_duplicates")]
1290 {
1291 __A::skip_value(&mut __map)?;
1292 continue;
1293 }
1294 #[cfg(feature = "strict")]
1295 return _serde::__private::Err(
1296 <__A::Error as _serde::de::Error>::duplicate_field(
1297 "userPlanes",
1298 ),
1299 );
1300 }
1301 m_userPlanes = _serde::__private::Some(
1302 match __A::next_value::<u32>(&mut __map) {
1303 _serde::__private::Ok(__val) => __val,
1304 _serde::__private::Err(__err) => {
1305 return _serde::__private::Err(__err);
1306 }
1307 },
1308 );
1309 }
1310 __Field::m_maxCharacterSpeedForSolver => {
1311 #[cfg(
1312 any(feature = "strict", feature = "ignore_duplicates")
1313 )]
1314 if _serde::__private::Option::is_some(
1315 &m_maxCharacterSpeedForSolver,
1316 ) {
1317 #[cfg(feature = "ignore_duplicates")]
1318 {
1319 __A::skip_value(&mut __map)?;
1320 continue;
1321 }
1322 #[cfg(feature = "strict")]
1323 return _serde::__private::Err(
1324 <__A::Error as _serde::de::Error>::duplicate_field(
1325 "maxCharacterSpeedForSolver",
1326 ),
1327 );
1328 }
1329 m_maxCharacterSpeedForSolver = _serde::__private::Some(
1330 match __A::next_value::<f32>(&mut __map) {
1331 _serde::__private::Ok(__val) => __val,
1332 _serde::__private::Err(__err) => {
1333 return _serde::__private::Err(__err);
1334 }
1335 },
1336 );
1337 }
1338 __Field::m_characterStrength => {
1339 #[cfg(
1340 any(feature = "strict", feature = "ignore_duplicates")
1341 )]
1342 if _serde::__private::Option::is_some(
1343 &m_characterStrength,
1344 ) {
1345 #[cfg(feature = "ignore_duplicates")]
1346 {
1347 __A::skip_value(&mut __map)?;
1348 continue;
1349 }
1350 #[cfg(feature = "strict")]
1351 return _serde::__private::Err(
1352 <__A::Error as _serde::de::Error>::duplicate_field(
1353 "characterStrength",
1354 ),
1355 );
1356 }
1357 m_characterStrength = _serde::__private::Some(
1358 match __A::next_value::<f32>(&mut __map) {
1359 _serde::__private::Ok(__val) => __val,
1360 _serde::__private::Err(__err) => {
1361 return _serde::__private::Err(__err);
1362 }
1363 },
1364 );
1365 }
1366 __Field::m_characterMass => {
1367 #[cfg(
1368 any(feature = "strict", feature = "ignore_duplicates")
1369 )]
1370 if _serde::__private::Option::is_some(&m_characterMass) {
1371 #[cfg(feature = "ignore_duplicates")]
1372 {
1373 __A::skip_value(&mut __map)?;
1374 continue;
1375 }
1376 #[cfg(feature = "strict")]
1377 return _serde::__private::Err(
1378 <__A::Error as _serde::de::Error>::duplicate_field(
1379 "characterMass",
1380 ),
1381 );
1382 }
1383 m_characterMass = _serde::__private::Some(
1384 match __A::next_value::<f32>(&mut __map) {
1385 _serde::__private::Ok(__val) => __val,
1386 _serde::__private::Err(__err) => {
1387 return _serde::__private::Err(__err);
1388 }
1389 },
1390 );
1391 }
1392 __Field::m_maxSlope => {
1393 #[cfg(
1394 any(feature = "strict", feature = "ignore_duplicates")
1395 )]
1396 if _serde::__private::Option::is_some(&m_maxSlope) {
1397 #[cfg(feature = "ignore_duplicates")]
1398 {
1399 __A::skip_value(&mut __map)?;
1400 continue;
1401 }
1402 #[cfg(feature = "strict")]
1403 return _serde::__private::Err(
1404 <__A::Error as _serde::de::Error>::duplicate_field(
1405 "maxSlope",
1406 ),
1407 );
1408 }
1409 m_maxSlope = _serde::__private::Some(
1410 match __A::next_value::<f32>(&mut __map) {
1411 _serde::__private::Ok(__val) => __val,
1412 _serde::__private::Err(__err) => {
1413 return _serde::__private::Err(__err);
1414 }
1415 },
1416 );
1417 }
1418 __Field::m_penetrationRecoverySpeed => {
1419 #[cfg(
1420 any(feature = "strict", feature = "ignore_duplicates")
1421 )]
1422 if _serde::__private::Option::is_some(
1423 &m_penetrationRecoverySpeed,
1424 ) {
1425 #[cfg(feature = "ignore_duplicates")]
1426 {
1427 __A::skip_value(&mut __map)?;
1428 continue;
1429 }
1430 #[cfg(feature = "strict")]
1431 return _serde::__private::Err(
1432 <__A::Error as _serde::de::Error>::duplicate_field(
1433 "penetrationRecoverySpeed",
1434 ),
1435 );
1436 }
1437 m_penetrationRecoverySpeed = _serde::__private::Some(
1438 match __A::next_value::<f32>(&mut __map) {
1439 _serde::__private::Ok(__val) => __val,
1440 _serde::__private::Err(__err) => {
1441 return _serde::__private::Err(__err);
1442 }
1443 },
1444 );
1445 }
1446 __Field::m_maxCastIterations => {
1447 #[cfg(
1448 any(feature = "strict", feature = "ignore_duplicates")
1449 )]
1450 if _serde::__private::Option::is_some(
1451 &m_maxCastIterations,
1452 ) {
1453 #[cfg(feature = "ignore_duplicates")]
1454 {
1455 __A::skip_value(&mut __map)?;
1456 continue;
1457 }
1458 #[cfg(feature = "strict")]
1459 return _serde::__private::Err(
1460 <__A::Error as _serde::de::Error>::duplicate_field(
1461 "maxCastIterations",
1462 ),
1463 );
1464 }
1465 m_maxCastIterations = _serde::__private::Some(
1466 match __A::next_value::<i32>(&mut __map) {
1467 _serde::__private::Ok(__val) => __val,
1468 _serde::__private::Err(__err) => {
1469 return _serde::__private::Err(__err);
1470 }
1471 },
1472 );
1473 }
1474 __Field::m_refreshManifoldInCheckSupport => {
1475 #[cfg(
1476 any(feature = "strict", feature = "ignore_duplicates")
1477 )]
1478 if _serde::__private::Option::is_some(
1479 &m_refreshManifoldInCheckSupport,
1480 ) {
1481 #[cfg(feature = "ignore_duplicates")]
1482 {
1483 __A::skip_value(&mut __map)?;
1484 continue;
1485 }
1486 #[cfg(feature = "strict")]
1487 return _serde::__private::Err(
1488 <__A::Error as _serde::de::Error>::duplicate_field(
1489 "refreshManifoldInCheckSupport",
1490 ),
1491 );
1492 }
1493 m_refreshManifoldInCheckSupport = _serde::__private::Some(
1494 match __A::next_value::<bool>(&mut __map) {
1495 _serde::__private::Ok(__val) => __val,
1496 _serde::__private::Err(__err) => {
1497 return _serde::__private::Err(__err);
1498 }
1499 },
1500 );
1501 }
1502 _ => __A::skip_value(&mut __map)?,
1503 }
1504 }
1505 let m_position = match m_position {
1506 _serde::__private::Some(__field) => __field,
1507 _serde::__private::None => {
1508 #[cfg(feature = "strict")]
1509 return _serde::__private::Err(
1510 <__A::Error as _serde::de::Error>::missing_field("position"),
1511 );
1512 #[cfg(not(feature = "strict"))] Default::default()
1513 }
1514 };
1515 let m_velocity = match m_velocity {
1516 _serde::__private::Some(__field) => __field,
1517 _serde::__private::None => {
1518 #[cfg(feature = "strict")]
1519 return _serde::__private::Err(
1520 <__A::Error as _serde::de::Error>::missing_field("velocity"),
1521 );
1522 #[cfg(not(feature = "strict"))] Default::default()
1523 }
1524 };
1525 let m_dynamicFriction = match m_dynamicFriction {
1526 _serde::__private::Some(__field) => __field,
1527 _serde::__private::None => {
1528 #[cfg(feature = "strict")]
1529 return _serde::__private::Err(
1530 <__A::Error as _serde::de::Error>::missing_field(
1531 "dynamicFriction",
1532 ),
1533 );
1534 #[cfg(not(feature = "strict"))] Default::default()
1535 }
1536 };
1537 let m_staticFriction = match m_staticFriction {
1538 _serde::__private::Some(__field) => __field,
1539 _serde::__private::None => {
1540 #[cfg(feature = "strict")]
1541 return _serde::__private::Err(
1542 <__A::Error as _serde::de::Error>::missing_field(
1543 "staticFriction",
1544 ),
1545 );
1546 #[cfg(not(feature = "strict"))] Default::default()
1547 }
1548 };
1549 let m_keepContactTolerance = match m_keepContactTolerance {
1550 _serde::__private::Some(__field) => __field,
1551 _serde::__private::None => {
1552 #[cfg(feature = "strict")]
1553 return _serde::__private::Err(
1554 <__A::Error as _serde::de::Error>::missing_field(
1555 "keepContactTolerance",
1556 ),
1557 );
1558 #[cfg(not(feature = "strict"))] Default::default()
1559 }
1560 };
1561 let m_up = match m_up {
1562 _serde::__private::Some(__field) => __field,
1563 _serde::__private::None => {
1564 #[cfg(feature = "strict")]
1565 return _serde::__private::Err(
1566 <__A::Error as _serde::de::Error>::missing_field("up"),
1567 );
1568 #[cfg(not(feature = "strict"))] Default::default()
1569 }
1570 };
1571 let m_extraUpStaticFriction = match m_extraUpStaticFriction {
1572 _serde::__private::Some(__field) => __field,
1573 _serde::__private::None => {
1574 #[cfg(feature = "strict")]
1575 return _serde::__private::Err(
1576 <__A::Error as _serde::de::Error>::missing_field(
1577 "extraUpStaticFriction",
1578 ),
1579 );
1580 #[cfg(not(feature = "strict"))] Default::default()
1581 }
1582 };
1583 let m_extraDownStaticFriction = match m_extraDownStaticFriction {
1584 _serde::__private::Some(__field) => __field,
1585 _serde::__private::None => {
1586 #[cfg(feature = "strict")]
1587 return _serde::__private::Err(
1588 <__A::Error as _serde::de::Error>::missing_field(
1589 "extraDownStaticFriction",
1590 ),
1591 );
1592 #[cfg(not(feature = "strict"))] Default::default()
1593 }
1594 };
1595 let m_shapePhantom = match m_shapePhantom {
1596 _serde::__private::Some(__field) => __field,
1597 _serde::__private::None => {
1598 #[cfg(feature = "strict")]
1599 return _serde::__private::Err(
1600 <__A::Error as _serde::de::Error>::missing_field(
1601 "shapePhantom",
1602 ),
1603 );
1604 #[cfg(not(feature = "strict"))] Default::default()
1605 }
1606 };
1607 let m_keepDistance = match m_keepDistance {
1608 _serde::__private::Some(__field) => __field,
1609 _serde::__private::None => {
1610 #[cfg(feature = "strict")]
1611 return _serde::__private::Err(
1612 <__A::Error as _serde::de::Error>::missing_field(
1613 "keepDistance",
1614 ),
1615 );
1616 #[cfg(not(feature = "strict"))] Default::default()
1617 }
1618 };
1619 let m_contactAngleSensitivity = match m_contactAngleSensitivity {
1620 _serde::__private::Some(__field) => __field,
1621 _serde::__private::None => {
1622 #[cfg(feature = "strict")]
1623 return _serde::__private::Err(
1624 <__A::Error as _serde::de::Error>::missing_field(
1625 "contactAngleSensitivity",
1626 ),
1627 );
1628 #[cfg(not(feature = "strict"))] Default::default()
1629 }
1630 };
1631 let m_userPlanes = match m_userPlanes {
1632 _serde::__private::Some(__field) => __field,
1633 _serde::__private::None => {
1634 #[cfg(feature = "strict")]
1635 return _serde::__private::Err(
1636 <__A::Error as _serde::de::Error>::missing_field(
1637 "userPlanes",
1638 ),
1639 );
1640 #[cfg(not(feature = "strict"))] Default::default()
1641 }
1642 };
1643 let m_maxCharacterSpeedForSolver = match m_maxCharacterSpeedForSolver {
1644 _serde::__private::Some(__field) => __field,
1645 _serde::__private::None => {
1646 #[cfg(feature = "strict")]
1647 return _serde::__private::Err(
1648 <__A::Error as _serde::de::Error>::missing_field(
1649 "maxCharacterSpeedForSolver",
1650 ),
1651 );
1652 #[cfg(not(feature = "strict"))] Default::default()
1653 }
1654 };
1655 let m_characterStrength = match m_characterStrength {
1656 _serde::__private::Some(__field) => __field,
1657 _serde::__private::None => {
1658 #[cfg(feature = "strict")]
1659 return _serde::__private::Err(
1660 <__A::Error as _serde::de::Error>::missing_field(
1661 "characterStrength",
1662 ),
1663 );
1664 #[cfg(not(feature = "strict"))] Default::default()
1665 }
1666 };
1667 let m_characterMass = match m_characterMass {
1668 _serde::__private::Some(__field) => __field,
1669 _serde::__private::None => {
1670 #[cfg(feature = "strict")]
1671 return _serde::__private::Err(
1672 <__A::Error as _serde::de::Error>::missing_field(
1673 "characterMass",
1674 ),
1675 );
1676 #[cfg(not(feature = "strict"))] Default::default()
1677 }
1678 };
1679 let m_maxSlope = match m_maxSlope {
1680 _serde::__private::Some(__field) => __field,
1681 _serde::__private::None => {
1682 #[cfg(feature = "strict")]
1683 return _serde::__private::Err(
1684 <__A::Error as _serde::de::Error>::missing_field("maxSlope"),
1685 );
1686 #[cfg(not(feature = "strict"))] Default::default()
1687 }
1688 };
1689 let m_penetrationRecoverySpeed = match m_penetrationRecoverySpeed {
1690 _serde::__private::Some(__field) => __field,
1691 _serde::__private::None => {
1692 #[cfg(feature = "strict")]
1693 return _serde::__private::Err(
1694 <__A::Error as _serde::de::Error>::missing_field(
1695 "penetrationRecoverySpeed",
1696 ),
1697 );
1698 #[cfg(not(feature = "strict"))] Default::default()
1699 }
1700 };
1701 let m_maxCastIterations = match m_maxCastIterations {
1702 _serde::__private::Some(__field) => __field,
1703 _serde::__private::None => {
1704 #[cfg(feature = "strict")]
1705 return _serde::__private::Err(
1706 <__A::Error as _serde::de::Error>::missing_field(
1707 "maxCastIterations",
1708 ),
1709 );
1710 #[cfg(not(feature = "strict"))] Default::default()
1711 }
1712 };
1713 let m_refreshManifoldInCheckSupport = match m_refreshManifoldInCheckSupport {
1714 _serde::__private::Some(__field) => __field,
1715 _serde::__private::None => {
1716 #[cfg(feature = "strict")]
1717 return _serde::__private::Err(
1718 <__A::Error as _serde::de::Error>::missing_field(
1719 "refreshManifoldInCheckSupport",
1720 ),
1721 );
1722 #[cfg(not(feature = "strict"))] Default::default()
1723 }
1724 };
1725 let __ptr = None;
1726 let parent = hkBaseObject { __ptr };
1727 let parent = hkReferencedObject {
1728 __ptr,
1729 parent,
1730 ..Default::default()
1731 };
1732 let parent = hkpCharacterControllerCinfo {
1733 __ptr,
1734 parent,
1735 };
1736 let __ptr = __A::class_ptr(&mut __map);
1737 _serde::__private::Ok(hkpCharacterProxyCinfo {
1738 __ptr,
1739 parent,
1740 m_position,
1741 m_velocity,
1742 m_dynamicFriction,
1743 m_staticFriction,
1744 m_keepContactTolerance,
1745 m_up,
1746 m_extraUpStaticFriction,
1747 m_extraDownStaticFriction,
1748 m_shapePhantom,
1749 m_keepDistance,
1750 m_contactAngleSensitivity,
1751 m_userPlanes,
1752 m_maxCharacterSpeedForSolver,
1753 m_characterStrength,
1754 m_characterMass,
1755 m_maxSlope,
1756 m_penetrationRecoverySpeed,
1757 m_maxCastIterations,
1758 m_refreshManifoldInCheckSupport,
1759 })
1760 }
1761 }
1762 const FIELDS: &[&str] = &[
1763 "position",
1764 "velocity",
1765 "dynamicFriction",
1766 "staticFriction",
1767 "keepContactTolerance",
1768 "up",
1769 "extraUpStaticFriction",
1770 "extraDownStaticFriction",
1771 "shapePhantom",
1772 "keepDistance",
1773 "contactAngleSensitivity",
1774 "userPlanes",
1775 "maxCharacterSpeedForSolver",
1776 "characterStrength",
1777 "characterMass",
1778 "maxSlope",
1779 "penetrationRecoverySpeed",
1780 "maxCastIterations",
1781 "refreshManifoldInCheckSupport",
1782 ];
1783 _serde::Deserializer::deserialize_struct(
1784 deserializer,
1785 "hkpCharacterProxyCinfo",
1786 FIELDS,
1787 __hkpCharacterProxyCinfoVisitor {
1788 marker: _serde::__private::PhantomData::<hkpCharacterProxyCinfo>,
1789 lifetime: _serde::__private::PhantomData,
1790 },
1791 )
1792 }
1793 }
1794};