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