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 hkbProxyModifier<'a> {
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 #[cfg_attr(feature = "serde", serde(borrow))]
30 pub parent: hkbModifier<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "proxyInfo"))]
36 #[cfg_attr(feature = "serde", serde(rename = "proxyInfo"))]
37 pub m_proxyInfo: hkbProxyModifierProxyInfo,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "linearVelocity"))]
43 #[cfg_attr(feature = "serde", serde(rename = "linearVelocity"))]
44 pub m_linearVelocity: Vector4,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "horizontalGain"))]
50 #[cfg_attr(feature = "serde", serde(rename = "horizontalGain"))]
51 pub m_horizontalGain: f32,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "verticalGain"))]
57 #[cfg_attr(feature = "serde", serde(rename = "verticalGain"))]
58 pub m_verticalGain: f32,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "maxHorizontalSeparation"))]
64 #[cfg_attr(feature = "serde", serde(rename = "maxHorizontalSeparation"))]
65 pub m_maxHorizontalSeparation: f32,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "maxVerticalSeparation"))]
71 #[cfg_attr(feature = "serde", serde(rename = "maxVerticalSeparation"))]
72 pub m_maxVerticalSeparation: f32,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "verticalDisplacementError"))]
78 #[cfg_attr(feature = "serde", serde(rename = "verticalDisplacementError"))]
79 pub m_verticalDisplacementError: f32,
80 #[cfg_attr(
85 feature = "json_schema",
86 schemars(rename = "verticalDisplacementErrorGain")
87 )]
88 #[cfg_attr(feature = "serde", serde(rename = "verticalDisplacementErrorGain"))]
89 pub m_verticalDisplacementErrorGain: f32,
90 #[cfg_attr(feature = "json_schema", schemars(rename = "maxVerticalDisplacement"))]
95 #[cfg_attr(feature = "serde", serde(rename = "maxVerticalDisplacement"))]
96 pub m_maxVerticalDisplacement: f32,
97 #[cfg_attr(feature = "json_schema", schemars(rename = "minVerticalDisplacement"))]
102 #[cfg_attr(feature = "serde", serde(rename = "minVerticalDisplacement"))]
103 pub m_minVerticalDisplacement: f32,
104 #[cfg_attr(feature = "json_schema", schemars(rename = "capsuleHeight"))]
109 #[cfg_attr(feature = "serde", serde(rename = "capsuleHeight"))]
110 pub m_capsuleHeight: f32,
111 #[cfg_attr(feature = "json_schema", schemars(rename = "capsuleRadius"))]
116 #[cfg_attr(feature = "serde", serde(rename = "capsuleRadius"))]
117 pub m_capsuleRadius: f32,
118 #[cfg_attr(feature = "json_schema", schemars(rename = "maxSlopeForRotation"))]
123 #[cfg_attr(feature = "serde", serde(rename = "maxSlopeForRotation"))]
124 pub m_maxSlopeForRotation: f32,
125 #[cfg_attr(feature = "json_schema", schemars(rename = "collisionFilterInfo"))]
130 #[cfg_attr(feature = "serde", serde(rename = "collisionFilterInfo"))]
131 pub m_collisionFilterInfo: u32,
132 #[cfg_attr(feature = "json_schema", schemars(rename = "phantomType"))]
137 #[cfg_attr(feature = "serde", serde(rename = "phantomType"))]
138 pub m_phantomType: PhantomType,
139 #[cfg_attr(feature = "json_schema", schemars(rename = "linearVelocityMode"))]
144 #[cfg_attr(feature = "serde", serde(rename = "linearVelocityMode"))]
145 pub m_linearVelocityMode: LinearVelocityMode,
146 #[cfg_attr(feature = "json_schema", schemars(rename = "ignoreIncomingRotation"))]
151 #[cfg_attr(feature = "serde", serde(rename = "ignoreIncomingRotation"))]
152 pub m_ignoreIncomingRotation: bool,
153 #[cfg_attr(
158 feature = "json_schema",
159 schemars(rename = "ignoreCollisionDuringRotation")
160 )]
161 #[cfg_attr(feature = "serde", serde(rename = "ignoreCollisionDuringRotation"))]
162 pub m_ignoreCollisionDuringRotation: bool,
163 #[cfg_attr(feature = "json_schema", schemars(rename = "ignoreIncomingTranslation"))]
168 #[cfg_attr(feature = "serde", serde(rename = "ignoreIncomingTranslation"))]
169 pub m_ignoreIncomingTranslation: bool,
170 #[cfg_attr(feature = "json_schema", schemars(rename = "includeDownwardMomentum"))]
175 #[cfg_attr(feature = "serde", serde(rename = "includeDownwardMomentum"))]
176 pub m_includeDownwardMomentum: bool,
177 #[cfg_attr(feature = "json_schema", schemars(rename = "followWorldFromModel"))]
182 #[cfg_attr(feature = "serde", serde(rename = "followWorldFromModel"))]
183 pub m_followWorldFromModel: bool,
184 #[cfg_attr(feature = "json_schema", schemars(rename = "isTouchingGround"))]
189 #[cfg_attr(feature = "serde", serde(rename = "isTouchingGround"))]
190 pub m_isTouchingGround: bool,
191 #[cfg_attr(feature = "json_schema", schemars(rename = "characterProxy"))]
197 #[cfg_attr(feature = "serde", serde(rename = "characterProxy"))]
198 pub m_characterProxy: Pointer,
199 #[cfg_attr(feature = "json_schema", schemars(rename = "phantom"))]
205 #[cfg_attr(feature = "serde", serde(rename = "phantom"))]
206 pub m_phantom: Pointer,
207 #[cfg_attr(feature = "json_schema", schemars(rename = "phantomShape"))]
213 #[cfg_attr(feature = "serde", serde(rename = "phantomShape"))]
214 pub m_phantomShape: Pointer,
215 #[cfg_attr(feature = "json_schema", schemars(rename = "horizontalDisplacement"))]
221 #[cfg_attr(feature = "serde", serde(rename = "horizontalDisplacement"))]
222 pub m_horizontalDisplacement: Vector4,
223 #[cfg_attr(feature = "json_schema", schemars(rename = "verticalDisplacement"))]
229 #[cfg_attr(feature = "serde", serde(rename = "verticalDisplacement"))]
230 pub m_verticalDisplacement: f32,
231 #[cfg_attr(feature = "json_schema", schemars(rename = "timestep"))]
237 #[cfg_attr(feature = "serde", serde(rename = "timestep"))]
238 pub m_timestep: f32,
239 #[cfg_attr(
245 feature = "json_schema",
246 schemars(rename = "previousFrameFollowWorldFromModel")
247 )]
248 #[cfg_attr(feature = "serde", serde(rename = "previousFrameFollowWorldFromModel"))]
249 pub m_previousFrameFollowWorldFromModel: bool,
250}
251const _: () = {
252 use havok_serde as _serde;
253 impl<'a> _serde::HavokClass for hkbProxyModifier<'a> {
254 #[inline]
255 fn name(&self) -> &'static str {
256 "hkbProxyModifier"
257 }
258 #[inline]
259 fn signature(&self) -> _serde::__private::Signature {
260 _serde::__private::Signature::new(0x8a41554f)
261 }
262 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
263 fn deps_indexes(&self) -> Vec<usize> {
264 let mut v = Vec::new();
265 v.push(self.parent.parent.parent.m_variableBindingSet.get());
266 v.extend(self.m_proxyInfo.deps_indexes());
267 v.push(self.m_characterProxy.get());
268 v.push(self.m_phantom.get());
269 v.push(self.m_phantomShape.get());
270 v
271 }
272 }
273 impl<'a> _serde::Serialize for hkbProxyModifier<'a> {
274 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
275 where
276 S: _serde::ser::Serializer,
277 {
278 let class_meta = self
279 .__ptr
280 .map(|name| (name, _serde::__private::Signature::new(0x8a41554f)));
281 let mut serializer = __serializer
282 .serialize_struct("hkbProxyModifier", class_meta, (256u64, 288u64))?;
283 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
284 serializer
285 .skip_field(
286 "memSizeAndFlags",
287 &self.parent.parent.parent.parent.m_memSizeAndFlags,
288 )?;
289 serializer
290 .skip_field(
291 "referenceCount",
292 &self.parent.parent.parent.parent.m_referenceCount,
293 )?;
294 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
295 serializer
296 .serialize_field(
297 "variableBindingSet",
298 &self.parent.parent.parent.m_variableBindingSet,
299 )?;
300 serializer
301 .skip_array_field(
302 "cachedBindables",
303 &self.parent.parent.parent.m_cachedBindables,
304 TypeSize::NonPtr,
305 )?;
306 serializer
307 .skip_field(
308 "areBindablesCached",
309 &self.parent.parent.parent.m_areBindablesCached,
310 )?;
311 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
312 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
313 serializer.serialize_field("name", &self.parent.parent.m_name)?;
314 serializer.skip_field("id", &self.parent.parent.m_id)?;
315 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
316 serializer
317 .skip_fixed_array_field(
318 "padNode",
319 self.parent.parent.m_padNode.as_slice(),
320 TypeSize::NonPtr,
321 )?;
322 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
323 serializer.serialize_field("enable", &self.parent.m_enable)?;
324 serializer
325 .skip_fixed_array_field(
326 "padModifier",
327 self.parent.m_padModifier.as_slice(),
328 TypeSize::NonPtr,
329 )?;
330 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
331 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
332 serializer.serialize_field("proxyInfo", &self.m_proxyInfo)?;
333 serializer.serialize_field("linearVelocity", &self.m_linearVelocity)?;
334 serializer.serialize_field("horizontalGain", &self.m_horizontalGain)?;
335 serializer.serialize_field("verticalGain", &self.m_verticalGain)?;
336 serializer
337 .serialize_field(
338 "maxHorizontalSeparation",
339 &self.m_maxHorizontalSeparation,
340 )?;
341 serializer
342 .serialize_field(
343 "maxVerticalSeparation",
344 &self.m_maxVerticalSeparation,
345 )?;
346 serializer
347 .serialize_field(
348 "verticalDisplacementError",
349 &self.m_verticalDisplacementError,
350 )?;
351 serializer
352 .serialize_field(
353 "verticalDisplacementErrorGain",
354 &self.m_verticalDisplacementErrorGain,
355 )?;
356 serializer
357 .serialize_field(
358 "maxVerticalDisplacement",
359 &self.m_maxVerticalDisplacement,
360 )?;
361 serializer
362 .serialize_field(
363 "minVerticalDisplacement",
364 &self.m_minVerticalDisplacement,
365 )?;
366 serializer.serialize_field("capsuleHeight", &self.m_capsuleHeight)?;
367 serializer.serialize_field("capsuleRadius", &self.m_capsuleRadius)?;
368 serializer
369 .serialize_field("maxSlopeForRotation", &self.m_maxSlopeForRotation)?;
370 serializer
371 .serialize_field("collisionFilterInfo", &self.m_collisionFilterInfo)?;
372 serializer.serialize_field("phantomType", &self.m_phantomType)?;
373 serializer
374 .serialize_field("linearVelocityMode", &self.m_linearVelocityMode)?;
375 serializer
376 .serialize_field(
377 "ignoreIncomingRotation",
378 &self.m_ignoreIncomingRotation,
379 )?;
380 serializer
381 .serialize_field(
382 "ignoreCollisionDuringRotation",
383 &self.m_ignoreCollisionDuringRotation,
384 )?;
385 serializer
386 .serialize_field(
387 "ignoreIncomingTranslation",
388 &self.m_ignoreIncomingTranslation,
389 )?;
390 serializer
391 .serialize_field(
392 "includeDownwardMomentum",
393 &self.m_includeDownwardMomentum,
394 )?;
395 serializer
396 .serialize_field("followWorldFromModel", &self.m_followWorldFromModel)?;
397 serializer.serialize_field("isTouchingGround", &self.m_isTouchingGround)?;
398 serializer.skip_field("characterProxy", &self.m_characterProxy)?;
399 serializer.skip_field("phantom", &self.m_phantom)?;
400 serializer.skip_field("phantomShape", &self.m_phantomShape)?;
401 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 0usize].as_slice())?;
402 serializer
403 .skip_field("horizontalDisplacement", &self.m_horizontalDisplacement)?;
404 serializer.skip_field("verticalDisplacement", &self.m_verticalDisplacement)?;
405 serializer.skip_field("timestep", &self.m_timestep)?;
406 serializer
407 .skip_field(
408 "previousFrameFollowWorldFromModel",
409 &self.m_previousFrameFollowWorldFromModel,
410 )?;
411 serializer.pad_field([0u8; 7usize].as_slice(), [0u8; 7usize].as_slice())?;
412 serializer.end()
413 }
414 }
415};
416#[doc(hidden)]
417#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
418const _: () = {
419 use havok_serde as _serde;
420 #[automatically_derived]
421 impl<'de> _serde::Deserialize<'de> for hkbProxyModifier<'de> {
422 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
423 where
424 __D: _serde::Deserializer<'de>,
425 {
426 #[allow(non_camel_case_types)]
427 enum __Field {
428 m_variableBindingSet,
429 m_userData,
430 m_name,
431 m_enable,
432 m_proxyInfo,
433 m_linearVelocity,
434 m_horizontalGain,
435 m_verticalGain,
436 m_maxHorizontalSeparation,
437 m_maxVerticalSeparation,
438 m_verticalDisplacementError,
439 m_verticalDisplacementErrorGain,
440 m_maxVerticalDisplacement,
441 m_minVerticalDisplacement,
442 m_capsuleHeight,
443 m_capsuleRadius,
444 m_maxSlopeForRotation,
445 m_collisionFilterInfo,
446 m_phantomType,
447 m_linearVelocityMode,
448 m_ignoreIncomingRotation,
449 m_ignoreCollisionDuringRotation,
450 m_ignoreIncomingTranslation,
451 m_includeDownwardMomentum,
452 m_followWorldFromModel,
453 m_isTouchingGround,
454 __ignore,
455 }
456 struct __FieldVisitor;
457 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
458 type Value = __Field;
459 fn expecting(
460 &self,
461 __formatter: &mut core::fmt::Formatter,
462 ) -> core::fmt::Result {
463 core::fmt::Formatter::write_str(__formatter, "field identifier")
464 }
465 #[allow(clippy::match_single_binding)]
467 #[allow(clippy::reversed_empty_ranges)]
468 #[allow(clippy::single_match)]
469 fn visit_key<__E>(
470 self,
471 __value: &str,
472 ) -> core::result::Result<Self::Value, __E>
473 where
474 __E: _serde::de::Error,
475 {
476 match __value {
477 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
478 "userData" => Ok(__Field::m_userData),
479 "name" => Ok(__Field::m_name),
480 "enable" => Ok(__Field::m_enable),
481 "proxyInfo" => Ok(__Field::m_proxyInfo),
482 "linearVelocity" => Ok(__Field::m_linearVelocity),
483 "horizontalGain" => Ok(__Field::m_horizontalGain),
484 "verticalGain" => Ok(__Field::m_verticalGain),
485 "maxHorizontalSeparation" => {
486 Ok(__Field::m_maxHorizontalSeparation)
487 }
488 "maxVerticalSeparation" => Ok(__Field::m_maxVerticalSeparation),
489 "verticalDisplacementError" => {
490 Ok(__Field::m_verticalDisplacementError)
491 }
492 "verticalDisplacementErrorGain" => {
493 Ok(__Field::m_verticalDisplacementErrorGain)
494 }
495 "maxVerticalDisplacement" => {
496 Ok(__Field::m_maxVerticalDisplacement)
497 }
498 "minVerticalDisplacement" => {
499 Ok(__Field::m_minVerticalDisplacement)
500 }
501 "capsuleHeight" => Ok(__Field::m_capsuleHeight),
502 "capsuleRadius" => Ok(__Field::m_capsuleRadius),
503 "maxSlopeForRotation" => Ok(__Field::m_maxSlopeForRotation),
504 "collisionFilterInfo" => Ok(__Field::m_collisionFilterInfo),
505 "phantomType" => Ok(__Field::m_phantomType),
506 "linearVelocityMode" => Ok(__Field::m_linearVelocityMode),
507 "ignoreIncomingRotation" => Ok(__Field::m_ignoreIncomingRotation),
508 "ignoreCollisionDuringRotation" => {
509 Ok(__Field::m_ignoreCollisionDuringRotation)
510 }
511 "ignoreIncomingTranslation" => {
512 Ok(__Field::m_ignoreIncomingTranslation)
513 }
514 "includeDownwardMomentum" => {
515 Ok(__Field::m_includeDownwardMomentum)
516 }
517 "followWorldFromModel" => Ok(__Field::m_followWorldFromModel),
518 "isTouchingGround" => Ok(__Field::m_isTouchingGround),
519 _ => Ok(__Field::__ignore),
520 }
521 }
522 }
523 impl<'de> _serde::Deserialize<'de> for __Field {
524 #[inline]
525 fn deserialize<__D>(
526 __deserializer: __D,
527 ) -> core::result::Result<Self, __D::Error>
528 where
529 __D: _serde::Deserializer<'de>,
530 {
531 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
532 }
533 }
534 struct __hkbProxyModifierVisitor<'de> {
535 marker: _serde::__private::PhantomData<hkbProxyModifier<'de>>,
536 lifetime: _serde::__private::PhantomData<&'de ()>,
537 }
538 #[allow(clippy::match_single_binding)]
539 #[allow(clippy::reversed_empty_ranges)]
540 #[allow(clippy::single_match)]
541 impl<'de> _serde::de::Visitor<'de> for __hkbProxyModifierVisitor<'de> {
542 type Value = hkbProxyModifier<'de>;
543 fn expecting(
544 &self,
545 __formatter: &mut core::fmt::Formatter,
546 ) -> core::fmt::Result {
547 core::fmt::Formatter::write_str(
548 __formatter,
549 "struct hkbProxyModifier",
550 )
551 }
552 fn visit_struct_for_bytes<__A>(
553 self,
554 mut __map: __A,
555 ) -> _serde::__private::Result<Self::Value, __A::Error>
556 where
557 __A: _serde::de::MapAccess<'de>,
558 {
559 let __ptr = __A::class_ptr(&mut __map);
560 let parent = __A::parent_value(&mut __map)?;
561 let mut m_proxyInfo: _serde::__private::Option<
562 hkbProxyModifierProxyInfo,
563 > = _serde::__private::None;
564 let mut m_linearVelocity: _serde::__private::Option<Vector4> = _serde::__private::None;
565 let mut m_horizontalGain: _serde::__private::Option<f32> = _serde::__private::None;
566 let mut m_verticalGain: _serde::__private::Option<f32> = _serde::__private::None;
567 let mut m_maxHorizontalSeparation: _serde::__private::Option<f32> = _serde::__private::None;
568 let mut m_maxVerticalSeparation: _serde::__private::Option<f32> = _serde::__private::None;
569 let mut m_verticalDisplacementError: _serde::__private::Option<
570 f32,
571 > = _serde::__private::None;
572 let mut m_verticalDisplacementErrorGain: _serde::__private::Option<
573 f32,
574 > = _serde::__private::None;
575 let mut m_maxVerticalDisplacement: _serde::__private::Option<f32> = _serde::__private::None;
576 let mut m_minVerticalDisplacement: _serde::__private::Option<f32> = _serde::__private::None;
577 let mut m_capsuleHeight: _serde::__private::Option<f32> = _serde::__private::None;
578 let mut m_capsuleRadius: _serde::__private::Option<f32> = _serde::__private::None;
579 let mut m_maxSlopeForRotation: _serde::__private::Option<f32> = _serde::__private::None;
580 let mut m_collisionFilterInfo: _serde::__private::Option<u32> = _serde::__private::None;
581 let mut m_phantomType: _serde::__private::Option<PhantomType> = _serde::__private::None;
582 let mut m_linearVelocityMode: _serde::__private::Option<
583 LinearVelocityMode,
584 > = _serde::__private::None;
585 let mut m_ignoreIncomingRotation: _serde::__private::Option<bool> = _serde::__private::None;
586 let mut m_ignoreCollisionDuringRotation: _serde::__private::Option<
587 bool,
588 > = _serde::__private::None;
589 let mut m_ignoreIncomingTranslation: _serde::__private::Option<
590 bool,
591 > = _serde::__private::None;
592 let mut m_includeDownwardMomentum: _serde::__private::Option<bool> = _serde::__private::None;
593 let mut m_followWorldFromModel: _serde::__private::Option<bool> = _serde::__private::None;
594 let mut m_isTouchingGround: _serde::__private::Option<bool> = _serde::__private::None;
595 let mut m_characterProxy: _serde::__private::Option<Pointer> = _serde::__private::None;
596 let mut m_phantom: _serde::__private::Option<Pointer> = _serde::__private::None;
597 let mut m_phantomShape: _serde::__private::Option<Pointer> = _serde::__private::None;
598 let mut m_horizontalDisplacement: _serde::__private::Option<
599 Vector4,
600 > = _serde::__private::None;
601 let mut m_verticalDisplacement: _serde::__private::Option<f32> = _serde::__private::None;
602 let mut m_timestep: _serde::__private::Option<f32> = _serde::__private::None;
603 let mut m_previousFrameFollowWorldFromModel: _serde::__private::Option<
604 bool,
605 > = _serde::__private::None;
606 for i in 0..29usize {
607 match i {
608 0usize => {
609 if _serde::__private::Option::is_some(&m_proxyInfo) {
610 return _serde::__private::Err(
611 <__A::Error as _serde::de::Error>::duplicate_field(
612 "proxyInfo",
613 ),
614 );
615 }
616 __A::pad(&mut __map, 4usize, 0usize)?;
617 m_proxyInfo = _serde::__private::Some(
618 match __A::next_value::<
619 hkbProxyModifierProxyInfo,
620 >(&mut __map) {
621 _serde::__private::Ok(__val) => __val,
622 _serde::__private::Err(__err) => {
623 return _serde::__private::Err(__err);
624 }
625 },
626 );
627 }
628 1usize => {
629 if _serde::__private::Option::is_some(&m_linearVelocity) {
630 return _serde::__private::Err(
631 <__A::Error as _serde::de::Error>::duplicate_field(
632 "linearVelocity",
633 ),
634 );
635 }
636 m_linearVelocity = _serde::__private::Some(
637 match __A::next_value::<Vector4>(&mut __map) {
638 _serde::__private::Ok(__val) => __val,
639 _serde::__private::Err(__err) => {
640 return _serde::__private::Err(__err);
641 }
642 },
643 );
644 }
645 2usize => {
646 if _serde::__private::Option::is_some(&m_horizontalGain) {
647 return _serde::__private::Err(
648 <__A::Error as _serde::de::Error>::duplicate_field(
649 "horizontalGain",
650 ),
651 );
652 }
653 m_horizontalGain = _serde::__private::Some(
654 match __A::next_value::<f32>(&mut __map) {
655 _serde::__private::Ok(__val) => __val,
656 _serde::__private::Err(__err) => {
657 return _serde::__private::Err(__err);
658 }
659 },
660 );
661 }
662 3usize => {
663 if _serde::__private::Option::is_some(&m_verticalGain) {
664 return _serde::__private::Err(
665 <__A::Error as _serde::de::Error>::duplicate_field(
666 "verticalGain",
667 ),
668 );
669 }
670 m_verticalGain = _serde::__private::Some(
671 match __A::next_value::<f32>(&mut __map) {
672 _serde::__private::Ok(__val) => __val,
673 _serde::__private::Err(__err) => {
674 return _serde::__private::Err(__err);
675 }
676 },
677 );
678 }
679 4usize => {
680 if _serde::__private::Option::is_some(
681 &m_maxHorizontalSeparation,
682 ) {
683 return _serde::__private::Err(
684 <__A::Error as _serde::de::Error>::duplicate_field(
685 "maxHorizontalSeparation",
686 ),
687 );
688 }
689 m_maxHorizontalSeparation = _serde::__private::Some(
690 match __A::next_value::<f32>(&mut __map) {
691 _serde::__private::Ok(__val) => __val,
692 _serde::__private::Err(__err) => {
693 return _serde::__private::Err(__err);
694 }
695 },
696 );
697 }
698 5usize => {
699 if _serde::__private::Option::is_some(
700 &m_maxVerticalSeparation,
701 ) {
702 return _serde::__private::Err(
703 <__A::Error as _serde::de::Error>::duplicate_field(
704 "maxVerticalSeparation",
705 ),
706 );
707 }
708 m_maxVerticalSeparation = _serde::__private::Some(
709 match __A::next_value::<f32>(&mut __map) {
710 _serde::__private::Ok(__val) => __val,
711 _serde::__private::Err(__err) => {
712 return _serde::__private::Err(__err);
713 }
714 },
715 );
716 }
717 6usize => {
718 if _serde::__private::Option::is_some(
719 &m_verticalDisplacementError,
720 ) {
721 return _serde::__private::Err(
722 <__A::Error as _serde::de::Error>::duplicate_field(
723 "verticalDisplacementError",
724 ),
725 );
726 }
727 m_verticalDisplacementError = _serde::__private::Some(
728 match __A::next_value::<f32>(&mut __map) {
729 _serde::__private::Ok(__val) => __val,
730 _serde::__private::Err(__err) => {
731 return _serde::__private::Err(__err);
732 }
733 },
734 );
735 }
736 7usize => {
737 if _serde::__private::Option::is_some(
738 &m_verticalDisplacementErrorGain,
739 ) {
740 return _serde::__private::Err(
741 <__A::Error as _serde::de::Error>::duplicate_field(
742 "verticalDisplacementErrorGain",
743 ),
744 );
745 }
746 m_verticalDisplacementErrorGain = _serde::__private::Some(
747 match __A::next_value::<f32>(&mut __map) {
748 _serde::__private::Ok(__val) => __val,
749 _serde::__private::Err(__err) => {
750 return _serde::__private::Err(__err);
751 }
752 },
753 );
754 }
755 8usize => {
756 if _serde::__private::Option::is_some(
757 &m_maxVerticalDisplacement,
758 ) {
759 return _serde::__private::Err(
760 <__A::Error as _serde::de::Error>::duplicate_field(
761 "maxVerticalDisplacement",
762 ),
763 );
764 }
765 m_maxVerticalDisplacement = _serde::__private::Some(
766 match __A::next_value::<f32>(&mut __map) {
767 _serde::__private::Ok(__val) => __val,
768 _serde::__private::Err(__err) => {
769 return _serde::__private::Err(__err);
770 }
771 },
772 );
773 }
774 9usize => {
775 if _serde::__private::Option::is_some(
776 &m_minVerticalDisplacement,
777 ) {
778 return _serde::__private::Err(
779 <__A::Error as _serde::de::Error>::duplicate_field(
780 "minVerticalDisplacement",
781 ),
782 );
783 }
784 m_minVerticalDisplacement = _serde::__private::Some(
785 match __A::next_value::<f32>(&mut __map) {
786 _serde::__private::Ok(__val) => __val,
787 _serde::__private::Err(__err) => {
788 return _serde::__private::Err(__err);
789 }
790 },
791 );
792 }
793 10usize => {
794 if _serde::__private::Option::is_some(&m_capsuleHeight) {
795 return _serde::__private::Err(
796 <__A::Error as _serde::de::Error>::duplicate_field(
797 "capsuleHeight",
798 ),
799 );
800 }
801 m_capsuleHeight = _serde::__private::Some(
802 match __A::next_value::<f32>(&mut __map) {
803 _serde::__private::Ok(__val) => __val,
804 _serde::__private::Err(__err) => {
805 return _serde::__private::Err(__err);
806 }
807 },
808 );
809 }
810 11usize => {
811 if _serde::__private::Option::is_some(&m_capsuleRadius) {
812 return _serde::__private::Err(
813 <__A::Error as _serde::de::Error>::duplicate_field(
814 "capsuleRadius",
815 ),
816 );
817 }
818 m_capsuleRadius = _serde::__private::Some(
819 match __A::next_value::<f32>(&mut __map) {
820 _serde::__private::Ok(__val) => __val,
821 _serde::__private::Err(__err) => {
822 return _serde::__private::Err(__err);
823 }
824 },
825 );
826 }
827 12usize => {
828 if _serde::__private::Option::is_some(
829 &m_maxSlopeForRotation,
830 ) {
831 return _serde::__private::Err(
832 <__A::Error as _serde::de::Error>::duplicate_field(
833 "maxSlopeForRotation",
834 ),
835 );
836 }
837 m_maxSlopeForRotation = _serde::__private::Some(
838 match __A::next_value::<f32>(&mut __map) {
839 _serde::__private::Ok(__val) => __val,
840 _serde::__private::Err(__err) => {
841 return _serde::__private::Err(__err);
842 }
843 },
844 );
845 }
846 13usize => {
847 if _serde::__private::Option::is_some(
848 &m_collisionFilterInfo,
849 ) {
850 return _serde::__private::Err(
851 <__A::Error as _serde::de::Error>::duplicate_field(
852 "collisionFilterInfo",
853 ),
854 );
855 }
856 m_collisionFilterInfo = _serde::__private::Some(
857 match __A::next_value::<u32>(&mut __map) {
858 _serde::__private::Ok(__val) => __val,
859 _serde::__private::Err(__err) => {
860 return _serde::__private::Err(__err);
861 }
862 },
863 );
864 }
865 14usize => {
866 if _serde::__private::Option::is_some(&m_phantomType) {
867 return _serde::__private::Err(
868 <__A::Error as _serde::de::Error>::duplicate_field(
869 "phantomType",
870 ),
871 );
872 }
873 m_phantomType = _serde::__private::Some(
874 match __A::next_value::<PhantomType>(&mut __map) {
875 _serde::__private::Ok(__val) => __val,
876 _serde::__private::Err(__err) => {
877 return _serde::__private::Err(__err);
878 }
879 },
880 );
881 }
882 15usize => {
883 if _serde::__private::Option::is_some(
884 &m_linearVelocityMode,
885 ) {
886 return _serde::__private::Err(
887 <__A::Error as _serde::de::Error>::duplicate_field(
888 "linearVelocityMode",
889 ),
890 );
891 }
892 m_linearVelocityMode = _serde::__private::Some(
893 match __A::next_value::<LinearVelocityMode>(&mut __map) {
894 _serde::__private::Ok(__val) => __val,
895 _serde::__private::Err(__err) => {
896 return _serde::__private::Err(__err);
897 }
898 },
899 );
900 }
901 16usize => {
902 if _serde::__private::Option::is_some(
903 &m_ignoreIncomingRotation,
904 ) {
905 return _serde::__private::Err(
906 <__A::Error as _serde::de::Error>::duplicate_field(
907 "ignoreIncomingRotation",
908 ),
909 );
910 }
911 m_ignoreIncomingRotation = _serde::__private::Some(
912 match __A::next_value::<bool>(&mut __map) {
913 _serde::__private::Ok(__val) => __val,
914 _serde::__private::Err(__err) => {
915 return _serde::__private::Err(__err);
916 }
917 },
918 );
919 }
920 17usize => {
921 if _serde::__private::Option::is_some(
922 &m_ignoreCollisionDuringRotation,
923 ) {
924 return _serde::__private::Err(
925 <__A::Error as _serde::de::Error>::duplicate_field(
926 "ignoreCollisionDuringRotation",
927 ),
928 );
929 }
930 m_ignoreCollisionDuringRotation = _serde::__private::Some(
931 match __A::next_value::<bool>(&mut __map) {
932 _serde::__private::Ok(__val) => __val,
933 _serde::__private::Err(__err) => {
934 return _serde::__private::Err(__err);
935 }
936 },
937 );
938 }
939 18usize => {
940 if _serde::__private::Option::is_some(
941 &m_ignoreIncomingTranslation,
942 ) {
943 return _serde::__private::Err(
944 <__A::Error as _serde::de::Error>::duplicate_field(
945 "ignoreIncomingTranslation",
946 ),
947 );
948 }
949 m_ignoreIncomingTranslation = _serde::__private::Some(
950 match __A::next_value::<bool>(&mut __map) {
951 _serde::__private::Ok(__val) => __val,
952 _serde::__private::Err(__err) => {
953 return _serde::__private::Err(__err);
954 }
955 },
956 );
957 }
958 19usize => {
959 if _serde::__private::Option::is_some(
960 &m_includeDownwardMomentum,
961 ) {
962 return _serde::__private::Err(
963 <__A::Error as _serde::de::Error>::duplicate_field(
964 "includeDownwardMomentum",
965 ),
966 );
967 }
968 m_includeDownwardMomentum = _serde::__private::Some(
969 match __A::next_value::<bool>(&mut __map) {
970 _serde::__private::Ok(__val) => __val,
971 _serde::__private::Err(__err) => {
972 return _serde::__private::Err(__err);
973 }
974 },
975 );
976 }
977 20usize => {
978 if _serde::__private::Option::is_some(
979 &m_followWorldFromModel,
980 ) {
981 return _serde::__private::Err(
982 <__A::Error as _serde::de::Error>::duplicate_field(
983 "followWorldFromModel",
984 ),
985 );
986 }
987 m_followWorldFromModel = _serde::__private::Some(
988 match __A::next_value::<bool>(&mut __map) {
989 _serde::__private::Ok(__val) => __val,
990 _serde::__private::Err(__err) => {
991 return _serde::__private::Err(__err);
992 }
993 },
994 );
995 }
996 21usize => {
997 if _serde::__private::Option::is_some(&m_isTouchingGround) {
998 return _serde::__private::Err(
999 <__A::Error as _serde::de::Error>::duplicate_field(
1000 "isTouchingGround",
1001 ),
1002 );
1003 }
1004 m_isTouchingGround = _serde::__private::Some(
1005 match __A::next_value::<bool>(&mut __map) {
1006 _serde::__private::Ok(__val) => __val,
1007 _serde::__private::Err(__err) => {
1008 return _serde::__private::Err(__err);
1009 }
1010 },
1011 );
1012 }
1013 22usize => {
1014 if _serde::__private::Option::is_some(&m_characterProxy) {
1015 return _serde::__private::Err(
1016 <__A::Error as _serde::de::Error>::duplicate_field(
1017 "characterProxy",
1018 ),
1019 );
1020 }
1021 m_characterProxy = _serde::__private::Some(
1022 match __A::next_value::<Pointer>(&mut __map) {
1023 _serde::__private::Ok(__val) => __val,
1024 _serde::__private::Err(__err) => {
1025 return _serde::__private::Err(__err);
1026 }
1027 },
1028 );
1029 }
1030 23usize => {
1031 if _serde::__private::Option::is_some(&m_phantom) {
1032 return _serde::__private::Err(
1033 <__A::Error as _serde::de::Error>::duplicate_field(
1034 "phantom",
1035 ),
1036 );
1037 }
1038 m_phantom = _serde::__private::Some(
1039 match __A::next_value::<Pointer>(&mut __map) {
1040 _serde::__private::Ok(__val) => __val,
1041 _serde::__private::Err(__err) => {
1042 return _serde::__private::Err(__err);
1043 }
1044 },
1045 );
1046 }
1047 24usize => {
1048 if _serde::__private::Option::is_some(&m_phantomShape) {
1049 return _serde::__private::Err(
1050 <__A::Error as _serde::de::Error>::duplicate_field(
1051 "phantomShape",
1052 ),
1053 );
1054 }
1055 m_phantomShape = _serde::__private::Some(
1056 match __A::next_value::<Pointer>(&mut __map) {
1057 _serde::__private::Ok(__val) => __val,
1058 _serde::__private::Err(__err) => {
1059 return _serde::__private::Err(__err);
1060 }
1061 },
1062 );
1063 }
1064 25usize => {
1065 if _serde::__private::Option::is_some(
1066 &m_horizontalDisplacement,
1067 ) {
1068 return _serde::__private::Err(
1069 <__A::Error as _serde::de::Error>::duplicate_field(
1070 "horizontalDisplacement",
1071 ),
1072 );
1073 }
1074 __A::pad(&mut __map, 12usize, 0usize)?;
1075 m_horizontalDisplacement = _serde::__private::Some(
1076 match __A::next_value::<Vector4>(&mut __map) {
1077 _serde::__private::Ok(__val) => __val,
1078 _serde::__private::Err(__err) => {
1079 return _serde::__private::Err(__err);
1080 }
1081 },
1082 );
1083 }
1084 26usize => {
1085 if _serde::__private::Option::is_some(
1086 &m_verticalDisplacement,
1087 ) {
1088 return _serde::__private::Err(
1089 <__A::Error as _serde::de::Error>::duplicate_field(
1090 "verticalDisplacement",
1091 ),
1092 );
1093 }
1094 m_verticalDisplacement = _serde::__private::Some(
1095 match __A::next_value::<f32>(&mut __map) {
1096 _serde::__private::Ok(__val) => __val,
1097 _serde::__private::Err(__err) => {
1098 return _serde::__private::Err(__err);
1099 }
1100 },
1101 );
1102 }
1103 27usize => {
1104 if _serde::__private::Option::is_some(&m_timestep) {
1105 return _serde::__private::Err(
1106 <__A::Error as _serde::de::Error>::duplicate_field(
1107 "timestep",
1108 ),
1109 );
1110 }
1111 m_timestep = _serde::__private::Some(
1112 match __A::next_value::<f32>(&mut __map) {
1113 _serde::__private::Ok(__val) => __val,
1114 _serde::__private::Err(__err) => {
1115 return _serde::__private::Err(__err);
1116 }
1117 },
1118 );
1119 }
1120 28usize => {
1121 if _serde::__private::Option::is_some(
1122 &m_previousFrameFollowWorldFromModel,
1123 ) {
1124 return _serde::__private::Err(
1125 <__A::Error as _serde::de::Error>::duplicate_field(
1126 "previousFrameFollowWorldFromModel",
1127 ),
1128 );
1129 }
1130 m_previousFrameFollowWorldFromModel = _serde::__private::Some(
1131 match __A::next_value::<bool>(&mut __map) {
1132 _serde::__private::Ok(__val) => __val,
1133 _serde::__private::Err(__err) => {
1134 return _serde::__private::Err(__err);
1135 }
1136 },
1137 );
1138 }
1139 _ => {}
1140 }
1141 }
1142 __A::pad(&mut __map, 7usize, 7usize)?;
1143 let m_proxyInfo = match m_proxyInfo {
1144 _serde::__private::Some(__field) => __field,
1145 _serde::__private::None => {
1146 return _serde::__private::Err(
1147 <__A::Error as _serde::de::Error>::missing_field(
1148 "proxyInfo",
1149 ),
1150 );
1151 }
1152 };
1153 let m_linearVelocity = match m_linearVelocity {
1154 _serde::__private::Some(__field) => __field,
1155 _serde::__private::None => {
1156 return _serde::__private::Err(
1157 <__A::Error as _serde::de::Error>::missing_field(
1158 "linearVelocity",
1159 ),
1160 );
1161 }
1162 };
1163 let m_horizontalGain = match m_horizontalGain {
1164 _serde::__private::Some(__field) => __field,
1165 _serde::__private::None => {
1166 return _serde::__private::Err(
1167 <__A::Error as _serde::de::Error>::missing_field(
1168 "horizontalGain",
1169 ),
1170 );
1171 }
1172 };
1173 let m_verticalGain = match m_verticalGain {
1174 _serde::__private::Some(__field) => __field,
1175 _serde::__private::None => {
1176 return _serde::__private::Err(
1177 <__A::Error as _serde::de::Error>::missing_field(
1178 "verticalGain",
1179 ),
1180 );
1181 }
1182 };
1183 let m_maxHorizontalSeparation = match m_maxHorizontalSeparation {
1184 _serde::__private::Some(__field) => __field,
1185 _serde::__private::None => {
1186 return _serde::__private::Err(
1187 <__A::Error as _serde::de::Error>::missing_field(
1188 "maxHorizontalSeparation",
1189 ),
1190 );
1191 }
1192 };
1193 let m_maxVerticalSeparation = match m_maxVerticalSeparation {
1194 _serde::__private::Some(__field) => __field,
1195 _serde::__private::None => {
1196 return _serde::__private::Err(
1197 <__A::Error as _serde::de::Error>::missing_field(
1198 "maxVerticalSeparation",
1199 ),
1200 );
1201 }
1202 };
1203 let m_verticalDisplacementError = match m_verticalDisplacementError {
1204 _serde::__private::Some(__field) => __field,
1205 _serde::__private::None => {
1206 return _serde::__private::Err(
1207 <__A::Error as _serde::de::Error>::missing_field(
1208 "verticalDisplacementError",
1209 ),
1210 );
1211 }
1212 };
1213 let m_verticalDisplacementErrorGain = match m_verticalDisplacementErrorGain {
1214 _serde::__private::Some(__field) => __field,
1215 _serde::__private::None => {
1216 return _serde::__private::Err(
1217 <__A::Error as _serde::de::Error>::missing_field(
1218 "verticalDisplacementErrorGain",
1219 ),
1220 );
1221 }
1222 };
1223 let m_maxVerticalDisplacement = match m_maxVerticalDisplacement {
1224 _serde::__private::Some(__field) => __field,
1225 _serde::__private::None => {
1226 return _serde::__private::Err(
1227 <__A::Error as _serde::de::Error>::missing_field(
1228 "maxVerticalDisplacement",
1229 ),
1230 );
1231 }
1232 };
1233 let m_minVerticalDisplacement = match m_minVerticalDisplacement {
1234 _serde::__private::Some(__field) => __field,
1235 _serde::__private::None => {
1236 return _serde::__private::Err(
1237 <__A::Error as _serde::de::Error>::missing_field(
1238 "minVerticalDisplacement",
1239 ),
1240 );
1241 }
1242 };
1243 let m_capsuleHeight = match m_capsuleHeight {
1244 _serde::__private::Some(__field) => __field,
1245 _serde::__private::None => {
1246 return _serde::__private::Err(
1247 <__A::Error as _serde::de::Error>::missing_field(
1248 "capsuleHeight",
1249 ),
1250 );
1251 }
1252 };
1253 let m_capsuleRadius = match m_capsuleRadius {
1254 _serde::__private::Some(__field) => __field,
1255 _serde::__private::None => {
1256 return _serde::__private::Err(
1257 <__A::Error as _serde::de::Error>::missing_field(
1258 "capsuleRadius",
1259 ),
1260 );
1261 }
1262 };
1263 let m_maxSlopeForRotation = match m_maxSlopeForRotation {
1264 _serde::__private::Some(__field) => __field,
1265 _serde::__private::None => {
1266 return _serde::__private::Err(
1267 <__A::Error as _serde::de::Error>::missing_field(
1268 "maxSlopeForRotation",
1269 ),
1270 );
1271 }
1272 };
1273 let m_collisionFilterInfo = match m_collisionFilterInfo {
1274 _serde::__private::Some(__field) => __field,
1275 _serde::__private::None => {
1276 return _serde::__private::Err(
1277 <__A::Error as _serde::de::Error>::missing_field(
1278 "collisionFilterInfo",
1279 ),
1280 );
1281 }
1282 };
1283 let m_phantomType = match m_phantomType {
1284 _serde::__private::Some(__field) => __field,
1285 _serde::__private::None => {
1286 return _serde::__private::Err(
1287 <__A::Error as _serde::de::Error>::missing_field(
1288 "phantomType",
1289 ),
1290 );
1291 }
1292 };
1293 let m_linearVelocityMode = match m_linearVelocityMode {
1294 _serde::__private::Some(__field) => __field,
1295 _serde::__private::None => {
1296 return _serde::__private::Err(
1297 <__A::Error as _serde::de::Error>::missing_field(
1298 "linearVelocityMode",
1299 ),
1300 );
1301 }
1302 };
1303 let m_ignoreIncomingRotation = match m_ignoreIncomingRotation {
1304 _serde::__private::Some(__field) => __field,
1305 _serde::__private::None => {
1306 return _serde::__private::Err(
1307 <__A::Error as _serde::de::Error>::missing_field(
1308 "ignoreIncomingRotation",
1309 ),
1310 );
1311 }
1312 };
1313 let m_ignoreCollisionDuringRotation = match m_ignoreCollisionDuringRotation {
1314 _serde::__private::Some(__field) => __field,
1315 _serde::__private::None => {
1316 return _serde::__private::Err(
1317 <__A::Error as _serde::de::Error>::missing_field(
1318 "ignoreCollisionDuringRotation",
1319 ),
1320 );
1321 }
1322 };
1323 let m_ignoreIncomingTranslation = match m_ignoreIncomingTranslation {
1324 _serde::__private::Some(__field) => __field,
1325 _serde::__private::None => {
1326 return _serde::__private::Err(
1327 <__A::Error as _serde::de::Error>::missing_field(
1328 "ignoreIncomingTranslation",
1329 ),
1330 );
1331 }
1332 };
1333 let m_includeDownwardMomentum = match m_includeDownwardMomentum {
1334 _serde::__private::Some(__field) => __field,
1335 _serde::__private::None => {
1336 return _serde::__private::Err(
1337 <__A::Error as _serde::de::Error>::missing_field(
1338 "includeDownwardMomentum",
1339 ),
1340 );
1341 }
1342 };
1343 let m_followWorldFromModel = match m_followWorldFromModel {
1344 _serde::__private::Some(__field) => __field,
1345 _serde::__private::None => {
1346 return _serde::__private::Err(
1347 <__A::Error as _serde::de::Error>::missing_field(
1348 "followWorldFromModel",
1349 ),
1350 );
1351 }
1352 };
1353 let m_isTouchingGround = match m_isTouchingGround {
1354 _serde::__private::Some(__field) => __field,
1355 _serde::__private::None => {
1356 return _serde::__private::Err(
1357 <__A::Error as _serde::de::Error>::missing_field(
1358 "isTouchingGround",
1359 ),
1360 );
1361 }
1362 };
1363 let m_characterProxy = match m_characterProxy {
1364 _serde::__private::Some(__field) => __field,
1365 _serde::__private::None => {
1366 return _serde::__private::Err(
1367 <__A::Error as _serde::de::Error>::missing_field(
1368 "characterProxy",
1369 ),
1370 );
1371 }
1372 };
1373 let m_phantom = match m_phantom {
1374 _serde::__private::Some(__field) => __field,
1375 _serde::__private::None => {
1376 return _serde::__private::Err(
1377 <__A::Error as _serde::de::Error>::missing_field("phantom"),
1378 );
1379 }
1380 };
1381 let m_phantomShape = match m_phantomShape {
1382 _serde::__private::Some(__field) => __field,
1383 _serde::__private::None => {
1384 return _serde::__private::Err(
1385 <__A::Error as _serde::de::Error>::missing_field(
1386 "phantomShape",
1387 ),
1388 );
1389 }
1390 };
1391 let m_horizontalDisplacement = match m_horizontalDisplacement {
1392 _serde::__private::Some(__field) => __field,
1393 _serde::__private::None => {
1394 return _serde::__private::Err(
1395 <__A::Error as _serde::de::Error>::missing_field(
1396 "horizontalDisplacement",
1397 ),
1398 );
1399 }
1400 };
1401 let m_verticalDisplacement = match m_verticalDisplacement {
1402 _serde::__private::Some(__field) => __field,
1403 _serde::__private::None => {
1404 return _serde::__private::Err(
1405 <__A::Error as _serde::de::Error>::missing_field(
1406 "verticalDisplacement",
1407 ),
1408 );
1409 }
1410 };
1411 let m_timestep = match m_timestep {
1412 _serde::__private::Some(__field) => __field,
1413 _serde::__private::None => {
1414 return _serde::__private::Err(
1415 <__A::Error as _serde::de::Error>::missing_field("timestep"),
1416 );
1417 }
1418 };
1419 let m_previousFrameFollowWorldFromModel = match m_previousFrameFollowWorldFromModel {
1420 _serde::__private::Some(__field) => __field,
1421 _serde::__private::None => {
1422 return _serde::__private::Err(
1423 <__A::Error as _serde::de::Error>::missing_field(
1424 "previousFrameFollowWorldFromModel",
1425 ),
1426 );
1427 }
1428 };
1429 _serde::__private::Ok(hkbProxyModifier {
1430 __ptr,
1431 parent,
1432 m_proxyInfo,
1433 m_linearVelocity,
1434 m_horizontalGain,
1435 m_verticalGain,
1436 m_maxHorizontalSeparation,
1437 m_maxVerticalSeparation,
1438 m_verticalDisplacementError,
1439 m_verticalDisplacementErrorGain,
1440 m_maxVerticalDisplacement,
1441 m_minVerticalDisplacement,
1442 m_capsuleHeight,
1443 m_capsuleRadius,
1444 m_maxSlopeForRotation,
1445 m_collisionFilterInfo,
1446 m_phantomType,
1447 m_linearVelocityMode,
1448 m_ignoreIncomingRotation,
1449 m_ignoreCollisionDuringRotation,
1450 m_ignoreIncomingTranslation,
1451 m_includeDownwardMomentum,
1452 m_followWorldFromModel,
1453 m_isTouchingGround,
1454 m_characterProxy,
1455 m_phantom,
1456 m_phantomShape,
1457 m_horizontalDisplacement,
1458 m_verticalDisplacement,
1459 m_timestep,
1460 m_previousFrameFollowWorldFromModel,
1461 })
1462 }
1463 #[allow(clippy::manual_unwrap_or_default)]
1464 fn visit_struct<__A>(
1465 self,
1466 mut __map: __A,
1467 ) -> _serde::__private::Result<Self::Value, __A::Error>
1468 where
1469 __A: _serde::de::MapAccess<'de>,
1470 {
1471 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
1472 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1473 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1474 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
1475 let mut m_proxyInfo: _serde::__private::Option<
1476 hkbProxyModifierProxyInfo,
1477 > = _serde::__private::None;
1478 let mut m_linearVelocity: _serde::__private::Option<Vector4> = _serde::__private::None;
1479 let mut m_horizontalGain: _serde::__private::Option<f32> = _serde::__private::None;
1480 let mut m_verticalGain: _serde::__private::Option<f32> = _serde::__private::None;
1481 let mut m_maxHorizontalSeparation: _serde::__private::Option<f32> = _serde::__private::None;
1482 let mut m_maxVerticalSeparation: _serde::__private::Option<f32> = _serde::__private::None;
1483 let mut m_verticalDisplacementError: _serde::__private::Option<
1484 f32,
1485 > = _serde::__private::None;
1486 let mut m_verticalDisplacementErrorGain: _serde::__private::Option<
1487 f32,
1488 > = _serde::__private::None;
1489 let mut m_maxVerticalDisplacement: _serde::__private::Option<f32> = _serde::__private::None;
1490 let mut m_minVerticalDisplacement: _serde::__private::Option<f32> = _serde::__private::None;
1491 let mut m_capsuleHeight: _serde::__private::Option<f32> = _serde::__private::None;
1492 let mut m_capsuleRadius: _serde::__private::Option<f32> = _serde::__private::None;
1493 let mut m_maxSlopeForRotation: _serde::__private::Option<f32> = _serde::__private::None;
1494 let mut m_collisionFilterInfo: _serde::__private::Option<u32> = _serde::__private::None;
1495 let mut m_phantomType: _serde::__private::Option<PhantomType> = _serde::__private::None;
1496 let mut m_linearVelocityMode: _serde::__private::Option<
1497 LinearVelocityMode,
1498 > = _serde::__private::None;
1499 let mut m_ignoreIncomingRotation: _serde::__private::Option<bool> = _serde::__private::None;
1500 let mut m_ignoreCollisionDuringRotation: _serde::__private::Option<
1501 bool,
1502 > = _serde::__private::None;
1503 let mut m_ignoreIncomingTranslation: _serde::__private::Option<
1504 bool,
1505 > = _serde::__private::None;
1506 let mut m_includeDownwardMomentum: _serde::__private::Option<bool> = _serde::__private::None;
1507 let mut m_followWorldFromModel: _serde::__private::Option<bool> = _serde::__private::None;
1508 let mut m_isTouchingGround: _serde::__private::Option<bool> = _serde::__private::None;
1509 while let _serde::__private::Some(__key) = {
1510 __A::next_key::<__Field>(&mut __map)?
1511 } {
1512 match __key {
1513 __Field::m_variableBindingSet => {
1514 #[cfg(
1515 any(feature = "strict", feature = "ignore_duplicates")
1516 )]
1517 if _serde::__private::Option::is_some(
1518 &m_variableBindingSet,
1519 ) {
1520 #[cfg(feature = "ignore_duplicates")]
1521 {
1522 __A::skip_value(&mut __map)?;
1523 continue;
1524 }
1525 #[cfg(feature = "strict")]
1526 return _serde::__private::Err(
1527 <__A::Error as _serde::de::Error>::duplicate_field(
1528 "variableBindingSet",
1529 ),
1530 );
1531 }
1532 m_variableBindingSet = _serde::__private::Some(
1533 match __A::next_value::<Pointer>(&mut __map) {
1534 _serde::__private::Ok(__val) => __val,
1535 _serde::__private::Err(__err) => {
1536 return _serde::__private::Err(__err);
1537 }
1538 },
1539 );
1540 }
1541 __Field::m_userData => {
1542 #[cfg(
1543 any(feature = "strict", feature = "ignore_duplicates")
1544 )]
1545 if _serde::__private::Option::is_some(&m_userData) {
1546 #[cfg(feature = "ignore_duplicates")]
1547 {
1548 __A::skip_value(&mut __map)?;
1549 continue;
1550 }
1551 #[cfg(feature = "strict")]
1552 return _serde::__private::Err(
1553 <__A::Error as _serde::de::Error>::duplicate_field(
1554 "userData",
1555 ),
1556 );
1557 }
1558 m_userData = _serde::__private::Some(
1559 match __A::next_value::<Ulong>(&mut __map) {
1560 _serde::__private::Ok(__val) => __val,
1561 _serde::__private::Err(__err) => {
1562 return _serde::__private::Err(__err);
1563 }
1564 },
1565 );
1566 }
1567 __Field::m_name => {
1568 #[cfg(
1569 any(feature = "strict", feature = "ignore_duplicates")
1570 )]
1571 if _serde::__private::Option::is_some(&m_name) {
1572 #[cfg(feature = "ignore_duplicates")]
1573 {
1574 __A::skip_value(&mut __map)?;
1575 continue;
1576 }
1577 #[cfg(feature = "strict")]
1578 return _serde::__private::Err(
1579 <__A::Error as _serde::de::Error>::duplicate_field("name"),
1580 );
1581 }
1582 m_name = _serde::__private::Some(
1583 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1584 _serde::__private::Ok(__val) => __val,
1585 _serde::__private::Err(__err) => {
1586 return _serde::__private::Err(__err);
1587 }
1588 },
1589 );
1590 }
1591 __Field::m_enable => {
1592 #[cfg(
1593 any(feature = "strict", feature = "ignore_duplicates")
1594 )]
1595 if _serde::__private::Option::is_some(&m_enable) {
1596 #[cfg(feature = "ignore_duplicates")]
1597 {
1598 __A::skip_value(&mut __map)?;
1599 continue;
1600 }
1601 #[cfg(feature = "strict")]
1602 return _serde::__private::Err(
1603 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
1604 );
1605 }
1606 m_enable = _serde::__private::Some(
1607 match __A::next_value::<bool>(&mut __map) {
1608 _serde::__private::Ok(__val) => __val,
1609 _serde::__private::Err(__err) => {
1610 return _serde::__private::Err(__err);
1611 }
1612 },
1613 );
1614 }
1615 __Field::m_proxyInfo => {
1616 #[cfg(
1617 any(feature = "strict", feature = "ignore_duplicates")
1618 )]
1619 if _serde::__private::Option::is_some(&m_proxyInfo) {
1620 #[cfg(feature = "ignore_duplicates")]
1621 {
1622 __A::skip_value(&mut __map)?;
1623 continue;
1624 }
1625 #[cfg(feature = "strict")]
1626 return _serde::__private::Err(
1627 <__A::Error as _serde::de::Error>::duplicate_field(
1628 "proxyInfo",
1629 ),
1630 );
1631 }
1632 m_proxyInfo = _serde::__private::Some(
1633 match __A::next_value::<
1634 hkbProxyModifierProxyInfo,
1635 >(&mut __map) {
1636 _serde::__private::Ok(__val) => __val,
1637 _serde::__private::Err(__err) => {
1638 return _serde::__private::Err(__err);
1639 }
1640 },
1641 );
1642 }
1643 __Field::m_linearVelocity => {
1644 #[cfg(
1645 any(feature = "strict", feature = "ignore_duplicates")
1646 )]
1647 if _serde::__private::Option::is_some(&m_linearVelocity) {
1648 #[cfg(feature = "ignore_duplicates")]
1649 {
1650 __A::skip_value(&mut __map)?;
1651 continue;
1652 }
1653 #[cfg(feature = "strict")]
1654 return _serde::__private::Err(
1655 <__A::Error as _serde::de::Error>::duplicate_field(
1656 "linearVelocity",
1657 ),
1658 );
1659 }
1660 m_linearVelocity = _serde::__private::Some(
1661 match __A::next_value::<Vector4>(&mut __map) {
1662 _serde::__private::Ok(__val) => __val,
1663 _serde::__private::Err(__err) => {
1664 return _serde::__private::Err(__err);
1665 }
1666 },
1667 );
1668 }
1669 __Field::m_horizontalGain => {
1670 #[cfg(
1671 any(feature = "strict", feature = "ignore_duplicates")
1672 )]
1673 if _serde::__private::Option::is_some(&m_horizontalGain) {
1674 #[cfg(feature = "ignore_duplicates")]
1675 {
1676 __A::skip_value(&mut __map)?;
1677 continue;
1678 }
1679 #[cfg(feature = "strict")]
1680 return _serde::__private::Err(
1681 <__A::Error as _serde::de::Error>::duplicate_field(
1682 "horizontalGain",
1683 ),
1684 );
1685 }
1686 m_horizontalGain = _serde::__private::Some(
1687 match __A::next_value::<f32>(&mut __map) {
1688 _serde::__private::Ok(__val) => __val,
1689 _serde::__private::Err(__err) => {
1690 return _serde::__private::Err(__err);
1691 }
1692 },
1693 );
1694 }
1695 __Field::m_verticalGain => {
1696 #[cfg(
1697 any(feature = "strict", feature = "ignore_duplicates")
1698 )]
1699 if _serde::__private::Option::is_some(&m_verticalGain) {
1700 #[cfg(feature = "ignore_duplicates")]
1701 {
1702 __A::skip_value(&mut __map)?;
1703 continue;
1704 }
1705 #[cfg(feature = "strict")]
1706 return _serde::__private::Err(
1707 <__A::Error as _serde::de::Error>::duplicate_field(
1708 "verticalGain",
1709 ),
1710 );
1711 }
1712 m_verticalGain = _serde::__private::Some(
1713 match __A::next_value::<f32>(&mut __map) {
1714 _serde::__private::Ok(__val) => __val,
1715 _serde::__private::Err(__err) => {
1716 return _serde::__private::Err(__err);
1717 }
1718 },
1719 );
1720 }
1721 __Field::m_maxHorizontalSeparation => {
1722 #[cfg(
1723 any(feature = "strict", feature = "ignore_duplicates")
1724 )]
1725 if _serde::__private::Option::is_some(
1726 &m_maxHorizontalSeparation,
1727 ) {
1728 #[cfg(feature = "ignore_duplicates")]
1729 {
1730 __A::skip_value(&mut __map)?;
1731 continue;
1732 }
1733 #[cfg(feature = "strict")]
1734 return _serde::__private::Err(
1735 <__A::Error as _serde::de::Error>::duplicate_field(
1736 "maxHorizontalSeparation",
1737 ),
1738 );
1739 }
1740 m_maxHorizontalSeparation = _serde::__private::Some(
1741 match __A::next_value::<f32>(&mut __map) {
1742 _serde::__private::Ok(__val) => __val,
1743 _serde::__private::Err(__err) => {
1744 return _serde::__private::Err(__err);
1745 }
1746 },
1747 );
1748 }
1749 __Field::m_maxVerticalSeparation => {
1750 #[cfg(
1751 any(feature = "strict", feature = "ignore_duplicates")
1752 )]
1753 if _serde::__private::Option::is_some(
1754 &m_maxVerticalSeparation,
1755 ) {
1756 #[cfg(feature = "ignore_duplicates")]
1757 {
1758 __A::skip_value(&mut __map)?;
1759 continue;
1760 }
1761 #[cfg(feature = "strict")]
1762 return _serde::__private::Err(
1763 <__A::Error as _serde::de::Error>::duplicate_field(
1764 "maxVerticalSeparation",
1765 ),
1766 );
1767 }
1768 m_maxVerticalSeparation = _serde::__private::Some(
1769 match __A::next_value::<f32>(&mut __map) {
1770 _serde::__private::Ok(__val) => __val,
1771 _serde::__private::Err(__err) => {
1772 return _serde::__private::Err(__err);
1773 }
1774 },
1775 );
1776 }
1777 __Field::m_verticalDisplacementError => {
1778 #[cfg(
1779 any(feature = "strict", feature = "ignore_duplicates")
1780 )]
1781 if _serde::__private::Option::is_some(
1782 &m_verticalDisplacementError,
1783 ) {
1784 #[cfg(feature = "ignore_duplicates")]
1785 {
1786 __A::skip_value(&mut __map)?;
1787 continue;
1788 }
1789 #[cfg(feature = "strict")]
1790 return _serde::__private::Err(
1791 <__A::Error as _serde::de::Error>::duplicate_field(
1792 "verticalDisplacementError",
1793 ),
1794 );
1795 }
1796 m_verticalDisplacementError = _serde::__private::Some(
1797 match __A::next_value::<f32>(&mut __map) {
1798 _serde::__private::Ok(__val) => __val,
1799 _serde::__private::Err(__err) => {
1800 return _serde::__private::Err(__err);
1801 }
1802 },
1803 );
1804 }
1805 __Field::m_verticalDisplacementErrorGain => {
1806 #[cfg(
1807 any(feature = "strict", feature = "ignore_duplicates")
1808 )]
1809 if _serde::__private::Option::is_some(
1810 &m_verticalDisplacementErrorGain,
1811 ) {
1812 #[cfg(feature = "ignore_duplicates")]
1813 {
1814 __A::skip_value(&mut __map)?;
1815 continue;
1816 }
1817 #[cfg(feature = "strict")]
1818 return _serde::__private::Err(
1819 <__A::Error as _serde::de::Error>::duplicate_field(
1820 "verticalDisplacementErrorGain",
1821 ),
1822 );
1823 }
1824 m_verticalDisplacementErrorGain = _serde::__private::Some(
1825 match __A::next_value::<f32>(&mut __map) {
1826 _serde::__private::Ok(__val) => __val,
1827 _serde::__private::Err(__err) => {
1828 return _serde::__private::Err(__err);
1829 }
1830 },
1831 );
1832 }
1833 __Field::m_maxVerticalDisplacement => {
1834 #[cfg(
1835 any(feature = "strict", feature = "ignore_duplicates")
1836 )]
1837 if _serde::__private::Option::is_some(
1838 &m_maxVerticalDisplacement,
1839 ) {
1840 #[cfg(feature = "ignore_duplicates")]
1841 {
1842 __A::skip_value(&mut __map)?;
1843 continue;
1844 }
1845 #[cfg(feature = "strict")]
1846 return _serde::__private::Err(
1847 <__A::Error as _serde::de::Error>::duplicate_field(
1848 "maxVerticalDisplacement",
1849 ),
1850 );
1851 }
1852 m_maxVerticalDisplacement = _serde::__private::Some(
1853 match __A::next_value::<f32>(&mut __map) {
1854 _serde::__private::Ok(__val) => __val,
1855 _serde::__private::Err(__err) => {
1856 return _serde::__private::Err(__err);
1857 }
1858 },
1859 );
1860 }
1861 __Field::m_minVerticalDisplacement => {
1862 #[cfg(
1863 any(feature = "strict", feature = "ignore_duplicates")
1864 )]
1865 if _serde::__private::Option::is_some(
1866 &m_minVerticalDisplacement,
1867 ) {
1868 #[cfg(feature = "ignore_duplicates")]
1869 {
1870 __A::skip_value(&mut __map)?;
1871 continue;
1872 }
1873 #[cfg(feature = "strict")]
1874 return _serde::__private::Err(
1875 <__A::Error as _serde::de::Error>::duplicate_field(
1876 "minVerticalDisplacement",
1877 ),
1878 );
1879 }
1880 m_minVerticalDisplacement = _serde::__private::Some(
1881 match __A::next_value::<f32>(&mut __map) {
1882 _serde::__private::Ok(__val) => __val,
1883 _serde::__private::Err(__err) => {
1884 return _serde::__private::Err(__err);
1885 }
1886 },
1887 );
1888 }
1889 __Field::m_capsuleHeight => {
1890 #[cfg(
1891 any(feature = "strict", feature = "ignore_duplicates")
1892 )]
1893 if _serde::__private::Option::is_some(&m_capsuleHeight) {
1894 #[cfg(feature = "ignore_duplicates")]
1895 {
1896 __A::skip_value(&mut __map)?;
1897 continue;
1898 }
1899 #[cfg(feature = "strict")]
1900 return _serde::__private::Err(
1901 <__A::Error as _serde::de::Error>::duplicate_field(
1902 "capsuleHeight",
1903 ),
1904 );
1905 }
1906 m_capsuleHeight = _serde::__private::Some(
1907 match __A::next_value::<f32>(&mut __map) {
1908 _serde::__private::Ok(__val) => __val,
1909 _serde::__private::Err(__err) => {
1910 return _serde::__private::Err(__err);
1911 }
1912 },
1913 );
1914 }
1915 __Field::m_capsuleRadius => {
1916 #[cfg(
1917 any(feature = "strict", feature = "ignore_duplicates")
1918 )]
1919 if _serde::__private::Option::is_some(&m_capsuleRadius) {
1920 #[cfg(feature = "ignore_duplicates")]
1921 {
1922 __A::skip_value(&mut __map)?;
1923 continue;
1924 }
1925 #[cfg(feature = "strict")]
1926 return _serde::__private::Err(
1927 <__A::Error as _serde::de::Error>::duplicate_field(
1928 "capsuleRadius",
1929 ),
1930 );
1931 }
1932 m_capsuleRadius = _serde::__private::Some(
1933 match __A::next_value::<f32>(&mut __map) {
1934 _serde::__private::Ok(__val) => __val,
1935 _serde::__private::Err(__err) => {
1936 return _serde::__private::Err(__err);
1937 }
1938 },
1939 );
1940 }
1941 __Field::m_maxSlopeForRotation => {
1942 #[cfg(
1943 any(feature = "strict", feature = "ignore_duplicates")
1944 )]
1945 if _serde::__private::Option::is_some(
1946 &m_maxSlopeForRotation,
1947 ) {
1948 #[cfg(feature = "ignore_duplicates")]
1949 {
1950 __A::skip_value(&mut __map)?;
1951 continue;
1952 }
1953 #[cfg(feature = "strict")]
1954 return _serde::__private::Err(
1955 <__A::Error as _serde::de::Error>::duplicate_field(
1956 "maxSlopeForRotation",
1957 ),
1958 );
1959 }
1960 m_maxSlopeForRotation = _serde::__private::Some(
1961 match __A::next_value::<f32>(&mut __map) {
1962 _serde::__private::Ok(__val) => __val,
1963 _serde::__private::Err(__err) => {
1964 return _serde::__private::Err(__err);
1965 }
1966 },
1967 );
1968 }
1969 __Field::m_collisionFilterInfo => {
1970 #[cfg(
1971 any(feature = "strict", feature = "ignore_duplicates")
1972 )]
1973 if _serde::__private::Option::is_some(
1974 &m_collisionFilterInfo,
1975 ) {
1976 #[cfg(feature = "ignore_duplicates")]
1977 {
1978 __A::skip_value(&mut __map)?;
1979 continue;
1980 }
1981 #[cfg(feature = "strict")]
1982 return _serde::__private::Err(
1983 <__A::Error as _serde::de::Error>::duplicate_field(
1984 "collisionFilterInfo",
1985 ),
1986 );
1987 }
1988 m_collisionFilterInfo = _serde::__private::Some(
1989 match __A::next_value::<u32>(&mut __map) {
1990 _serde::__private::Ok(__val) => __val,
1991 _serde::__private::Err(__err) => {
1992 return _serde::__private::Err(__err);
1993 }
1994 },
1995 );
1996 }
1997 __Field::m_phantomType => {
1998 #[cfg(
1999 any(feature = "strict", feature = "ignore_duplicates")
2000 )]
2001 if _serde::__private::Option::is_some(&m_phantomType) {
2002 #[cfg(feature = "ignore_duplicates")]
2003 {
2004 __A::skip_value(&mut __map)?;
2005 continue;
2006 }
2007 #[cfg(feature = "strict")]
2008 return _serde::__private::Err(
2009 <__A::Error as _serde::de::Error>::duplicate_field(
2010 "phantomType",
2011 ),
2012 );
2013 }
2014 m_phantomType = _serde::__private::Some(
2015 match __A::next_value::<PhantomType>(&mut __map) {
2016 _serde::__private::Ok(__val) => __val,
2017 _serde::__private::Err(__err) => {
2018 return _serde::__private::Err(__err);
2019 }
2020 },
2021 );
2022 }
2023 __Field::m_linearVelocityMode => {
2024 #[cfg(
2025 any(feature = "strict", feature = "ignore_duplicates")
2026 )]
2027 if _serde::__private::Option::is_some(
2028 &m_linearVelocityMode,
2029 ) {
2030 #[cfg(feature = "ignore_duplicates")]
2031 {
2032 __A::skip_value(&mut __map)?;
2033 continue;
2034 }
2035 #[cfg(feature = "strict")]
2036 return _serde::__private::Err(
2037 <__A::Error as _serde::de::Error>::duplicate_field(
2038 "linearVelocityMode",
2039 ),
2040 );
2041 }
2042 m_linearVelocityMode = _serde::__private::Some(
2043 match __A::next_value::<LinearVelocityMode>(&mut __map) {
2044 _serde::__private::Ok(__val) => __val,
2045 _serde::__private::Err(__err) => {
2046 return _serde::__private::Err(__err);
2047 }
2048 },
2049 );
2050 }
2051 __Field::m_ignoreIncomingRotation => {
2052 #[cfg(
2053 any(feature = "strict", feature = "ignore_duplicates")
2054 )]
2055 if _serde::__private::Option::is_some(
2056 &m_ignoreIncomingRotation,
2057 ) {
2058 #[cfg(feature = "ignore_duplicates")]
2059 {
2060 __A::skip_value(&mut __map)?;
2061 continue;
2062 }
2063 #[cfg(feature = "strict")]
2064 return _serde::__private::Err(
2065 <__A::Error as _serde::de::Error>::duplicate_field(
2066 "ignoreIncomingRotation",
2067 ),
2068 );
2069 }
2070 m_ignoreIncomingRotation = _serde::__private::Some(
2071 match __A::next_value::<bool>(&mut __map) {
2072 _serde::__private::Ok(__val) => __val,
2073 _serde::__private::Err(__err) => {
2074 return _serde::__private::Err(__err);
2075 }
2076 },
2077 );
2078 }
2079 __Field::m_ignoreCollisionDuringRotation => {
2080 #[cfg(
2081 any(feature = "strict", feature = "ignore_duplicates")
2082 )]
2083 if _serde::__private::Option::is_some(
2084 &m_ignoreCollisionDuringRotation,
2085 ) {
2086 #[cfg(feature = "ignore_duplicates")]
2087 {
2088 __A::skip_value(&mut __map)?;
2089 continue;
2090 }
2091 #[cfg(feature = "strict")]
2092 return _serde::__private::Err(
2093 <__A::Error as _serde::de::Error>::duplicate_field(
2094 "ignoreCollisionDuringRotation",
2095 ),
2096 );
2097 }
2098 m_ignoreCollisionDuringRotation = _serde::__private::Some(
2099 match __A::next_value::<bool>(&mut __map) {
2100 _serde::__private::Ok(__val) => __val,
2101 _serde::__private::Err(__err) => {
2102 return _serde::__private::Err(__err);
2103 }
2104 },
2105 );
2106 }
2107 __Field::m_ignoreIncomingTranslation => {
2108 #[cfg(
2109 any(feature = "strict", feature = "ignore_duplicates")
2110 )]
2111 if _serde::__private::Option::is_some(
2112 &m_ignoreIncomingTranslation,
2113 ) {
2114 #[cfg(feature = "ignore_duplicates")]
2115 {
2116 __A::skip_value(&mut __map)?;
2117 continue;
2118 }
2119 #[cfg(feature = "strict")]
2120 return _serde::__private::Err(
2121 <__A::Error as _serde::de::Error>::duplicate_field(
2122 "ignoreIncomingTranslation",
2123 ),
2124 );
2125 }
2126 m_ignoreIncomingTranslation = _serde::__private::Some(
2127 match __A::next_value::<bool>(&mut __map) {
2128 _serde::__private::Ok(__val) => __val,
2129 _serde::__private::Err(__err) => {
2130 return _serde::__private::Err(__err);
2131 }
2132 },
2133 );
2134 }
2135 __Field::m_includeDownwardMomentum => {
2136 #[cfg(
2137 any(feature = "strict", feature = "ignore_duplicates")
2138 )]
2139 if _serde::__private::Option::is_some(
2140 &m_includeDownwardMomentum,
2141 ) {
2142 #[cfg(feature = "ignore_duplicates")]
2143 {
2144 __A::skip_value(&mut __map)?;
2145 continue;
2146 }
2147 #[cfg(feature = "strict")]
2148 return _serde::__private::Err(
2149 <__A::Error as _serde::de::Error>::duplicate_field(
2150 "includeDownwardMomentum",
2151 ),
2152 );
2153 }
2154 m_includeDownwardMomentum = _serde::__private::Some(
2155 match __A::next_value::<bool>(&mut __map) {
2156 _serde::__private::Ok(__val) => __val,
2157 _serde::__private::Err(__err) => {
2158 return _serde::__private::Err(__err);
2159 }
2160 },
2161 );
2162 }
2163 __Field::m_followWorldFromModel => {
2164 #[cfg(
2165 any(feature = "strict", feature = "ignore_duplicates")
2166 )]
2167 if _serde::__private::Option::is_some(
2168 &m_followWorldFromModel,
2169 ) {
2170 #[cfg(feature = "ignore_duplicates")]
2171 {
2172 __A::skip_value(&mut __map)?;
2173 continue;
2174 }
2175 #[cfg(feature = "strict")]
2176 return _serde::__private::Err(
2177 <__A::Error as _serde::de::Error>::duplicate_field(
2178 "followWorldFromModel",
2179 ),
2180 );
2181 }
2182 m_followWorldFromModel = _serde::__private::Some(
2183 match __A::next_value::<bool>(&mut __map) {
2184 _serde::__private::Ok(__val) => __val,
2185 _serde::__private::Err(__err) => {
2186 return _serde::__private::Err(__err);
2187 }
2188 },
2189 );
2190 }
2191 __Field::m_isTouchingGround => {
2192 #[cfg(
2193 any(feature = "strict", feature = "ignore_duplicates")
2194 )]
2195 if _serde::__private::Option::is_some(&m_isTouchingGround) {
2196 #[cfg(feature = "ignore_duplicates")]
2197 {
2198 __A::skip_value(&mut __map)?;
2199 continue;
2200 }
2201 #[cfg(feature = "strict")]
2202 return _serde::__private::Err(
2203 <__A::Error as _serde::de::Error>::duplicate_field(
2204 "isTouchingGround",
2205 ),
2206 );
2207 }
2208 m_isTouchingGround = _serde::__private::Some(
2209 match __A::next_value::<bool>(&mut __map) {
2210 _serde::__private::Ok(__val) => __val,
2211 _serde::__private::Err(__err) => {
2212 return _serde::__private::Err(__err);
2213 }
2214 },
2215 );
2216 }
2217 _ => __A::skip_value(&mut __map)?,
2218 }
2219 }
2220 let m_variableBindingSet = match m_variableBindingSet {
2221 _serde::__private::Some(__field) => __field,
2222 _serde::__private::None => {
2223 #[cfg(feature = "strict")]
2224 return _serde::__private::Err(
2225 <__A::Error as _serde::de::Error>::missing_field(
2226 "variableBindingSet",
2227 ),
2228 );
2229 #[cfg(not(feature = "strict"))] Default::default()
2230 }
2231 };
2232 let m_userData = match m_userData {
2233 _serde::__private::Some(__field) => __field,
2234 _serde::__private::None => {
2235 #[cfg(feature = "strict")]
2236 return _serde::__private::Err(
2237 <__A::Error as _serde::de::Error>::missing_field("userData"),
2238 );
2239 #[cfg(not(feature = "strict"))] Default::default()
2240 }
2241 };
2242 let m_name = match m_name {
2243 _serde::__private::Some(__field) => __field,
2244 _serde::__private::None => {
2245 #[cfg(feature = "strict")]
2246 return _serde::__private::Err(
2247 <__A::Error as _serde::de::Error>::missing_field("name"),
2248 );
2249 #[cfg(not(feature = "strict"))] Default::default()
2250 }
2251 };
2252 let m_enable = match m_enable {
2253 _serde::__private::Some(__field) => __field,
2254 _serde::__private::None => {
2255 #[cfg(feature = "strict")]
2256 return _serde::__private::Err(
2257 <__A::Error as _serde::de::Error>::missing_field("enable"),
2258 );
2259 #[cfg(not(feature = "strict"))] Default::default()
2260 }
2261 };
2262 let m_proxyInfo = match m_proxyInfo {
2263 _serde::__private::Some(__field) => __field,
2264 _serde::__private::None => {
2265 #[cfg(feature = "strict")]
2266 return _serde::__private::Err(
2267 <__A::Error as _serde::de::Error>::missing_field(
2268 "proxyInfo",
2269 ),
2270 );
2271 #[cfg(not(feature = "strict"))] Default::default()
2272 }
2273 };
2274 let m_linearVelocity = match m_linearVelocity {
2275 _serde::__private::Some(__field) => __field,
2276 _serde::__private::None => {
2277 #[cfg(feature = "strict")]
2278 return _serde::__private::Err(
2279 <__A::Error as _serde::de::Error>::missing_field(
2280 "linearVelocity",
2281 ),
2282 );
2283 #[cfg(not(feature = "strict"))] Default::default()
2284 }
2285 };
2286 let m_horizontalGain = match m_horizontalGain {
2287 _serde::__private::Some(__field) => __field,
2288 _serde::__private::None => {
2289 #[cfg(feature = "strict")]
2290 return _serde::__private::Err(
2291 <__A::Error as _serde::de::Error>::missing_field(
2292 "horizontalGain",
2293 ),
2294 );
2295 #[cfg(not(feature = "strict"))] Default::default()
2296 }
2297 };
2298 let m_verticalGain = match m_verticalGain {
2299 _serde::__private::Some(__field) => __field,
2300 _serde::__private::None => {
2301 #[cfg(feature = "strict")]
2302 return _serde::__private::Err(
2303 <__A::Error as _serde::de::Error>::missing_field(
2304 "verticalGain",
2305 ),
2306 );
2307 #[cfg(not(feature = "strict"))] Default::default()
2308 }
2309 };
2310 let m_maxHorizontalSeparation = match m_maxHorizontalSeparation {
2311 _serde::__private::Some(__field) => __field,
2312 _serde::__private::None => {
2313 #[cfg(feature = "strict")]
2314 return _serde::__private::Err(
2315 <__A::Error as _serde::de::Error>::missing_field(
2316 "maxHorizontalSeparation",
2317 ),
2318 );
2319 #[cfg(not(feature = "strict"))] Default::default()
2320 }
2321 };
2322 let m_maxVerticalSeparation = match m_maxVerticalSeparation {
2323 _serde::__private::Some(__field) => __field,
2324 _serde::__private::None => {
2325 #[cfg(feature = "strict")]
2326 return _serde::__private::Err(
2327 <__A::Error as _serde::de::Error>::missing_field(
2328 "maxVerticalSeparation",
2329 ),
2330 );
2331 #[cfg(not(feature = "strict"))] Default::default()
2332 }
2333 };
2334 let m_verticalDisplacementError = match m_verticalDisplacementError {
2335 _serde::__private::Some(__field) => __field,
2336 _serde::__private::None => {
2337 #[cfg(feature = "strict")]
2338 return _serde::__private::Err(
2339 <__A::Error as _serde::de::Error>::missing_field(
2340 "verticalDisplacementError",
2341 ),
2342 );
2343 #[cfg(not(feature = "strict"))] Default::default()
2344 }
2345 };
2346 let m_verticalDisplacementErrorGain = match m_verticalDisplacementErrorGain {
2347 _serde::__private::Some(__field) => __field,
2348 _serde::__private::None => {
2349 #[cfg(feature = "strict")]
2350 return _serde::__private::Err(
2351 <__A::Error as _serde::de::Error>::missing_field(
2352 "verticalDisplacementErrorGain",
2353 ),
2354 );
2355 #[cfg(not(feature = "strict"))] Default::default()
2356 }
2357 };
2358 let m_maxVerticalDisplacement = match m_maxVerticalDisplacement {
2359 _serde::__private::Some(__field) => __field,
2360 _serde::__private::None => {
2361 #[cfg(feature = "strict")]
2362 return _serde::__private::Err(
2363 <__A::Error as _serde::de::Error>::missing_field(
2364 "maxVerticalDisplacement",
2365 ),
2366 );
2367 #[cfg(not(feature = "strict"))] Default::default()
2368 }
2369 };
2370 let m_minVerticalDisplacement = match m_minVerticalDisplacement {
2371 _serde::__private::Some(__field) => __field,
2372 _serde::__private::None => {
2373 #[cfg(feature = "strict")]
2374 return _serde::__private::Err(
2375 <__A::Error as _serde::de::Error>::missing_field(
2376 "minVerticalDisplacement",
2377 ),
2378 );
2379 #[cfg(not(feature = "strict"))] Default::default()
2380 }
2381 };
2382 let m_capsuleHeight = match m_capsuleHeight {
2383 _serde::__private::Some(__field) => __field,
2384 _serde::__private::None => {
2385 #[cfg(feature = "strict")]
2386 return _serde::__private::Err(
2387 <__A::Error as _serde::de::Error>::missing_field(
2388 "capsuleHeight",
2389 ),
2390 );
2391 #[cfg(not(feature = "strict"))] Default::default()
2392 }
2393 };
2394 let m_capsuleRadius = match m_capsuleRadius {
2395 _serde::__private::Some(__field) => __field,
2396 _serde::__private::None => {
2397 #[cfg(feature = "strict")]
2398 return _serde::__private::Err(
2399 <__A::Error as _serde::de::Error>::missing_field(
2400 "capsuleRadius",
2401 ),
2402 );
2403 #[cfg(not(feature = "strict"))] Default::default()
2404 }
2405 };
2406 let m_maxSlopeForRotation = match m_maxSlopeForRotation {
2407 _serde::__private::Some(__field) => __field,
2408 _serde::__private::None => {
2409 #[cfg(feature = "strict")]
2410 return _serde::__private::Err(
2411 <__A::Error as _serde::de::Error>::missing_field(
2412 "maxSlopeForRotation",
2413 ),
2414 );
2415 #[cfg(not(feature = "strict"))] Default::default()
2416 }
2417 };
2418 let m_collisionFilterInfo = match m_collisionFilterInfo {
2419 _serde::__private::Some(__field) => __field,
2420 _serde::__private::None => {
2421 #[cfg(feature = "strict")]
2422 return _serde::__private::Err(
2423 <__A::Error as _serde::de::Error>::missing_field(
2424 "collisionFilterInfo",
2425 ),
2426 );
2427 #[cfg(not(feature = "strict"))] Default::default()
2428 }
2429 };
2430 let m_phantomType = match m_phantomType {
2431 _serde::__private::Some(__field) => __field,
2432 _serde::__private::None => {
2433 #[cfg(feature = "strict")]
2434 return _serde::__private::Err(
2435 <__A::Error as _serde::de::Error>::missing_field(
2436 "phantomType",
2437 ),
2438 );
2439 #[cfg(not(feature = "strict"))] Default::default()
2440 }
2441 };
2442 let m_linearVelocityMode = match m_linearVelocityMode {
2443 _serde::__private::Some(__field) => __field,
2444 _serde::__private::None => {
2445 #[cfg(feature = "strict")]
2446 return _serde::__private::Err(
2447 <__A::Error as _serde::de::Error>::missing_field(
2448 "linearVelocityMode",
2449 ),
2450 );
2451 #[cfg(not(feature = "strict"))] Default::default()
2452 }
2453 };
2454 let m_ignoreIncomingRotation = match m_ignoreIncomingRotation {
2455 _serde::__private::Some(__field) => __field,
2456 _serde::__private::None => {
2457 #[cfg(feature = "strict")]
2458 return _serde::__private::Err(
2459 <__A::Error as _serde::de::Error>::missing_field(
2460 "ignoreIncomingRotation",
2461 ),
2462 );
2463 #[cfg(not(feature = "strict"))] Default::default()
2464 }
2465 };
2466 let m_ignoreCollisionDuringRotation = match m_ignoreCollisionDuringRotation {
2467 _serde::__private::Some(__field) => __field,
2468 _serde::__private::None => {
2469 #[cfg(feature = "strict")]
2470 return _serde::__private::Err(
2471 <__A::Error as _serde::de::Error>::missing_field(
2472 "ignoreCollisionDuringRotation",
2473 ),
2474 );
2475 #[cfg(not(feature = "strict"))] Default::default()
2476 }
2477 };
2478 let m_ignoreIncomingTranslation = match m_ignoreIncomingTranslation {
2479 _serde::__private::Some(__field) => __field,
2480 _serde::__private::None => {
2481 #[cfg(feature = "strict")]
2482 return _serde::__private::Err(
2483 <__A::Error as _serde::de::Error>::missing_field(
2484 "ignoreIncomingTranslation",
2485 ),
2486 );
2487 #[cfg(not(feature = "strict"))] Default::default()
2488 }
2489 };
2490 let m_includeDownwardMomentum = match m_includeDownwardMomentum {
2491 _serde::__private::Some(__field) => __field,
2492 _serde::__private::None => {
2493 #[cfg(feature = "strict")]
2494 return _serde::__private::Err(
2495 <__A::Error as _serde::de::Error>::missing_field(
2496 "includeDownwardMomentum",
2497 ),
2498 );
2499 #[cfg(not(feature = "strict"))] Default::default()
2500 }
2501 };
2502 let m_followWorldFromModel = match m_followWorldFromModel {
2503 _serde::__private::Some(__field) => __field,
2504 _serde::__private::None => {
2505 #[cfg(feature = "strict")]
2506 return _serde::__private::Err(
2507 <__A::Error as _serde::de::Error>::missing_field(
2508 "followWorldFromModel",
2509 ),
2510 );
2511 #[cfg(not(feature = "strict"))] Default::default()
2512 }
2513 };
2514 let m_isTouchingGround = match m_isTouchingGround {
2515 _serde::__private::Some(__field) => __field,
2516 _serde::__private::None => {
2517 #[cfg(feature = "strict")]
2518 return _serde::__private::Err(
2519 <__A::Error as _serde::de::Error>::missing_field(
2520 "isTouchingGround",
2521 ),
2522 );
2523 #[cfg(not(feature = "strict"))] Default::default()
2524 }
2525 };
2526 let __ptr = None;
2527 let parent = hkBaseObject { __ptr };
2528 let parent = hkReferencedObject {
2529 __ptr,
2530 parent,
2531 ..Default::default()
2532 };
2533 let parent = hkbBindable {
2534 __ptr,
2535 parent,
2536 m_variableBindingSet,
2537 ..Default::default()
2538 };
2539 let parent = hkbNode {
2540 __ptr,
2541 parent,
2542 m_userData,
2543 m_name,
2544 ..Default::default()
2545 };
2546 let parent = hkbModifier {
2547 __ptr,
2548 parent,
2549 m_enable,
2550 ..Default::default()
2551 };
2552 let __ptr = __A::class_ptr(&mut __map);
2553 _serde::__private::Ok(hkbProxyModifier {
2554 __ptr,
2555 parent,
2556 m_proxyInfo,
2557 m_linearVelocity,
2558 m_horizontalGain,
2559 m_verticalGain,
2560 m_maxHorizontalSeparation,
2561 m_maxVerticalSeparation,
2562 m_verticalDisplacementError,
2563 m_verticalDisplacementErrorGain,
2564 m_maxVerticalDisplacement,
2565 m_minVerticalDisplacement,
2566 m_capsuleHeight,
2567 m_capsuleRadius,
2568 m_maxSlopeForRotation,
2569 m_collisionFilterInfo,
2570 m_phantomType,
2571 m_linearVelocityMode,
2572 m_ignoreIncomingRotation,
2573 m_ignoreCollisionDuringRotation,
2574 m_ignoreIncomingTranslation,
2575 m_includeDownwardMomentum,
2576 m_followWorldFromModel,
2577 m_isTouchingGround,
2578 ..Default::default()
2579 })
2580 }
2581 }
2582 const FIELDS: &[&str] = &[
2583 "proxyInfo",
2584 "linearVelocity",
2585 "horizontalGain",
2586 "verticalGain",
2587 "maxHorizontalSeparation",
2588 "maxVerticalSeparation",
2589 "verticalDisplacementError",
2590 "verticalDisplacementErrorGain",
2591 "maxVerticalDisplacement",
2592 "minVerticalDisplacement",
2593 "capsuleHeight",
2594 "capsuleRadius",
2595 "maxSlopeForRotation",
2596 "collisionFilterInfo",
2597 "phantomType",
2598 "linearVelocityMode",
2599 "ignoreIncomingRotation",
2600 "ignoreCollisionDuringRotation",
2601 "ignoreIncomingTranslation",
2602 "includeDownwardMomentum",
2603 "followWorldFromModel",
2604 "isTouchingGround",
2605 "characterProxy",
2606 "phantom",
2607 "phantomShape",
2608 "horizontalDisplacement",
2609 "verticalDisplacement",
2610 "timestep",
2611 "previousFrameFollowWorldFromModel",
2612 ];
2613 _serde::Deserializer::deserialize_struct(
2614 deserializer,
2615 "hkbProxyModifier",
2616 FIELDS,
2617 __hkbProxyModifierVisitor {
2618 marker: _serde::__private::PhantomData::<hkbProxyModifier>,
2619 lifetime: _serde::__private::PhantomData,
2620 },
2621 )
2622 }
2623 }
2624};
2625#[allow(non_upper_case_globals, non_snake_case)]
2628#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
2629#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2630#[derive(
2631 Debug,
2632 Clone,
2633 Default,
2634 PartialEq,
2635 Eq,
2636 PartialOrd,
2637 Ord,
2638 num_derive::ToPrimitive,
2639 num_derive::FromPrimitive,
2640)]
2641pub enum PhantomType {
2642 #[default]
2643 PHANTOM_TYPE_SIMPLE = 0isize,
2644 PHANTOM_TYPE_CACHING = 1isize,
2645}
2646#[allow(non_upper_case_globals, non_snake_case)]
2649#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
2650#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2651#[derive(
2652 Debug,
2653 Clone,
2654 Default,
2655 PartialEq,
2656 Eq,
2657 PartialOrd,
2658 Ord,
2659 num_derive::ToPrimitive,
2660 num_derive::FromPrimitive,
2661)]
2662pub enum LinearVelocityMode {
2663 #[default]
2664 LINEAR_VELOCITY_MODE_WORLD = 0isize,
2665 LINEAR_VELOCITY_MODE_MODEL = 1isize,
2666}
2667const _: () = {
2668 use havok_serde as __serde;
2669 impl __serde::Serialize for PhantomType {
2670 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
2671 where
2672 S: __serde::ser::Serializer,
2673 {
2674 let mut __serializer = __serializer.serialize_enum_flags()?;
2675 match self {
2676 Self::PHANTOM_TYPE_SIMPLE => {
2677 __serializer.serialize_field("PHANTOM_TYPE_SIMPLE", &0u64)
2678 }
2679 Self::PHANTOM_TYPE_CACHING => {
2680 __serializer.serialize_field("PHANTOM_TYPE_CACHING", &1u64)
2681 }
2682 }?;
2683 use num_traits::ToPrimitive as _;
2684 let num = self
2685 .to_i8()
2686 .ok_or(S::Error::custom("Failed enum PhantomType to_i8"))?;
2687 __serializer.serialize_bits(&num)?;
2688 __serializer.end()
2689 }
2690 }
2691};
2692const _: () = {
2693 use havok_serde as __serde;
2694 impl __serde::Serialize for LinearVelocityMode {
2695 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
2696 where
2697 S: __serde::ser::Serializer,
2698 {
2699 let mut __serializer = __serializer.serialize_enum_flags()?;
2700 match self {
2701 Self::LINEAR_VELOCITY_MODE_WORLD => {
2702 __serializer.serialize_field("LINEAR_VELOCITY_MODE_WORLD", &0u64)
2703 }
2704 Self::LINEAR_VELOCITY_MODE_MODEL => {
2705 __serializer.serialize_field("LINEAR_VELOCITY_MODE_MODEL", &1u64)
2706 }
2707 }?;
2708 use num_traits::ToPrimitive as _;
2709 let num = self
2710 .to_i8()
2711 .ok_or(S::Error::custom("Failed enum LinearVelocityMode to_i8"))?;
2712 __serializer.serialize_bits(&num)?;
2713 __serializer.end()
2714 }
2715 }
2716};
2717#[doc(hidden)]
2718#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
2719const _: () = {
2720 #[allow(unused_extern_crates, clippy::useless_attribute)]
2721 extern crate havok_serde as _serde;
2722 #[automatically_derived]
2723 impl<'de> _serde::Deserialize<'de> for PhantomType {
2724 fn deserialize<__D>(
2725 __deserializer: __D,
2726 ) -> _serde::__private::Result<Self, __D::Error>
2727 where
2728 __D: _serde::Deserializer<'de>,
2729 {
2730 #[allow(non_camel_case_types)]
2731 #[doc(hidden)]
2732 enum __Field {
2733 __field0,
2734 __field1,
2735 }
2736 #[doc(hidden)]
2737 struct __FieldVisitor;
2738 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
2739 type Value = __Field;
2740 fn expecting(
2741 &self,
2742 __formatter: &mut _serde::__private::Formatter,
2743 ) -> _serde::__private::fmt::Result {
2744 _serde::__private::Formatter::write_str(
2745 __formatter,
2746 "variant identifier",
2747 )
2748 }
2749 fn visit_int8<__E>(
2750 self,
2751 __value: i8,
2752 ) -> _serde::__private::Result<Self::Value, __E>
2753 where
2754 __E: _serde::de::Error,
2755 {
2756 match __value {
2757 0i8 => _serde::__private::Ok(__Field::__field0),
2758 1i8 => _serde::__private::Ok(__Field::__field1),
2759 _ => {
2760 _serde::__private::Err(
2761 _serde::de::Error::invalid_value(
2762 _serde::de::Unexpected::Int8(__value),
2763 &"value(i8) of variant is one of 0, 1",
2764 ),
2765 )
2766 }
2767 }
2768 }
2769 fn visit_stringptr<__E>(
2770 self,
2771 __value: StringPtr<'de>,
2772 ) -> _serde::__private::Result<Self::Value, __E>
2773 where
2774 __E: _serde::de::Error,
2775 {
2776 if let Some(__value) = __value.into_inner() {
2777 match __value.as_ref() {
2778 v if v == "0"
2779 || v.eq_ignore_ascii_case("PHANTOM_TYPE_SIMPLE") => {
2780 _serde::__private::Ok(__Field::__field0)
2781 }
2782 v if v == "1"
2783 || v.eq_ignore_ascii_case("PHANTOM_TYPE_CACHING") => {
2784 _serde::__private::Ok(__Field::__field1)
2785 }
2786 _ => {
2787 _serde::__private::Err(
2788 _serde::de::Error::unknown_variant(&__value, VARIANTS),
2789 )
2790 }
2791 }
2792 } else {
2793 _serde::__private::Err(
2794 _serde::de::Error::unknown_variant("None", VARIANTS),
2795 )
2796 }
2797 }
2798 }
2799 impl<'de> _serde::Deserialize<'de> for __Field {
2800 #[inline]
2801 fn deserialize<__D>(
2802 __deserializer: __D,
2803 ) -> _serde::__private::Result<Self, __D::Error>
2804 where
2805 __D: _serde::Deserializer<'de>,
2806 {
2807 _serde::Deserializer::deserialize_identifier(
2808 __deserializer,
2809 _serde::de::ReadEnumSize::Int8,
2810 __FieldVisitor,
2811 )
2812 }
2813 }
2814 #[doc(hidden)]
2815 struct __Visitor<'de> {
2816 marker: _serde::__private::PhantomData<PhantomType>,
2817 lifetime: _serde::__private::PhantomData<&'de ()>,
2818 }
2819 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
2820 type Value = PhantomType;
2821 fn expecting(
2822 &self,
2823 __formatter: &mut _serde::__private::Formatter,
2824 ) -> _serde::__private::fmt::Result {
2825 _serde::__private::Formatter::write_str(
2826 __formatter,
2827 "enum PhantomType",
2828 )
2829 }
2830 fn visit_enum<__A>(
2831 self,
2832 __data: __A,
2833 ) -> _serde::__private::Result<Self::Value, __A::Error>
2834 where
2835 __A: _serde::de::EnumAccess<'de>,
2836 {
2837 match _serde::de::EnumAccess::variant(__data)? {
2838 (__Field::__field0, __variant) => {
2839 _serde::de::VariantAccess::unit_variant(__variant)?;
2840 _serde::__private::Ok(PhantomType::PHANTOM_TYPE_SIMPLE)
2841 }
2842 (__Field::__field1, __variant) => {
2843 _serde::de::VariantAccess::unit_variant(__variant)?;
2844 _serde::__private::Ok(PhantomType::PHANTOM_TYPE_CACHING)
2845 }
2846 }
2847 }
2848 }
2849 #[doc(hidden)]
2850 const VARIANTS: &'static [&'static str] = &[
2851 "PHANTOM_TYPE_SIMPLE",
2852 "PHANTOM_TYPE_CACHING",
2853 ];
2854 _serde::Deserializer::deserialize_enum(
2855 __deserializer,
2856 "PhantomType",
2857 VARIANTS,
2858 __Visitor {
2859 marker: _serde::__private::PhantomData::<PhantomType>,
2860 lifetime: _serde::__private::PhantomData,
2861 },
2862 )
2863 }
2864 }
2865};
2866#[doc(hidden)]
2867#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
2868const _: () = {
2869 #[allow(unused_extern_crates, clippy::useless_attribute)]
2870 extern crate havok_serde as _serde;
2871 #[automatically_derived]
2872 impl<'de> _serde::Deserialize<'de> for LinearVelocityMode {
2873 fn deserialize<__D>(
2874 __deserializer: __D,
2875 ) -> _serde::__private::Result<Self, __D::Error>
2876 where
2877 __D: _serde::Deserializer<'de>,
2878 {
2879 #[allow(non_camel_case_types)]
2880 #[doc(hidden)]
2881 enum __Field {
2882 __field0,
2883 __field1,
2884 }
2885 #[doc(hidden)]
2886 struct __FieldVisitor;
2887 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
2888 type Value = __Field;
2889 fn expecting(
2890 &self,
2891 __formatter: &mut _serde::__private::Formatter,
2892 ) -> _serde::__private::fmt::Result {
2893 _serde::__private::Formatter::write_str(
2894 __formatter,
2895 "variant identifier",
2896 )
2897 }
2898 fn visit_int8<__E>(
2899 self,
2900 __value: i8,
2901 ) -> _serde::__private::Result<Self::Value, __E>
2902 where
2903 __E: _serde::de::Error,
2904 {
2905 match __value {
2906 0i8 => _serde::__private::Ok(__Field::__field0),
2907 1i8 => _serde::__private::Ok(__Field::__field1),
2908 _ => {
2909 _serde::__private::Err(
2910 _serde::de::Error::invalid_value(
2911 _serde::de::Unexpected::Int8(__value),
2912 &"value(i8) of variant is one of 0, 1",
2913 ),
2914 )
2915 }
2916 }
2917 }
2918 fn visit_stringptr<__E>(
2919 self,
2920 __value: StringPtr<'de>,
2921 ) -> _serde::__private::Result<Self::Value, __E>
2922 where
2923 __E: _serde::de::Error,
2924 {
2925 if let Some(__value) = __value.into_inner() {
2926 match __value.as_ref() {
2927 v if v == "0"
2928 || v.eq_ignore_ascii_case("LINEAR_VELOCITY_MODE_WORLD") => {
2929 _serde::__private::Ok(__Field::__field0)
2930 }
2931 v if v == "1"
2932 || v.eq_ignore_ascii_case("LINEAR_VELOCITY_MODE_MODEL") => {
2933 _serde::__private::Ok(__Field::__field1)
2934 }
2935 _ => {
2936 _serde::__private::Err(
2937 _serde::de::Error::unknown_variant(&__value, VARIANTS),
2938 )
2939 }
2940 }
2941 } else {
2942 _serde::__private::Err(
2943 _serde::de::Error::unknown_variant("None", VARIANTS),
2944 )
2945 }
2946 }
2947 }
2948 impl<'de> _serde::Deserialize<'de> for __Field {
2949 #[inline]
2950 fn deserialize<__D>(
2951 __deserializer: __D,
2952 ) -> _serde::__private::Result<Self, __D::Error>
2953 where
2954 __D: _serde::Deserializer<'de>,
2955 {
2956 _serde::Deserializer::deserialize_identifier(
2957 __deserializer,
2958 _serde::de::ReadEnumSize::Int8,
2959 __FieldVisitor,
2960 )
2961 }
2962 }
2963 #[doc(hidden)]
2964 struct __Visitor<'de> {
2965 marker: _serde::__private::PhantomData<LinearVelocityMode>,
2966 lifetime: _serde::__private::PhantomData<&'de ()>,
2967 }
2968 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
2969 type Value = LinearVelocityMode;
2970 fn expecting(
2971 &self,
2972 __formatter: &mut _serde::__private::Formatter,
2973 ) -> _serde::__private::fmt::Result {
2974 _serde::__private::Formatter::write_str(
2975 __formatter,
2976 "enum LinearVelocityMode",
2977 )
2978 }
2979 fn visit_enum<__A>(
2980 self,
2981 __data: __A,
2982 ) -> _serde::__private::Result<Self::Value, __A::Error>
2983 where
2984 __A: _serde::de::EnumAccess<'de>,
2985 {
2986 match _serde::de::EnumAccess::variant(__data)? {
2987 (__Field::__field0, __variant) => {
2988 _serde::de::VariantAccess::unit_variant(__variant)?;
2989 _serde::__private::Ok(
2990 LinearVelocityMode::LINEAR_VELOCITY_MODE_WORLD,
2991 )
2992 }
2993 (__Field::__field1, __variant) => {
2994 _serde::de::VariantAccess::unit_variant(__variant)?;
2995 _serde::__private::Ok(
2996 LinearVelocityMode::LINEAR_VELOCITY_MODE_MODEL,
2997 )
2998 }
2999 }
3000 }
3001 }
3002 #[doc(hidden)]
3003 const VARIANTS: &'static [&'static str] = &[
3004 "LINEAR_VELOCITY_MODE_WORLD",
3005 "LINEAR_VELOCITY_MODE_MODEL",
3006 ];
3007 _serde::Deserializer::deserialize_enum(
3008 __deserializer,
3009 "LinearVelocityMode",
3010 VARIANTS,
3011 __Visitor {
3012 marker: _serde::__private::PhantomData::<LinearVelocityMode>,
3013 lifetime: _serde::__private::PhantomData,
3014 },
3015 )
3016 }
3017 }
3018};