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