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 hkbDetectCloseToGroundModifier<'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 = "closeToGroundEvent"))]
36 #[cfg_attr(feature = "serde", serde(rename = "closeToGroundEvent"))]
37 pub m_closeToGroundEvent: hkbEventProperty,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "closeToGroundHeight"))]
43 #[cfg_attr(feature = "serde", serde(rename = "closeToGroundHeight"))]
44 pub m_closeToGroundHeight: f32,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "raycastDistanceDown"))]
50 #[cfg_attr(feature = "serde", serde(rename = "raycastDistanceDown"))]
51 pub m_raycastDistanceDown: f32,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "collisionFilterInfo"))]
57 #[cfg_attr(feature = "serde", serde(rename = "collisionFilterInfo"))]
58 pub m_collisionFilterInfo: u32,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "boneIndex"))]
64 #[cfg_attr(feature = "serde", serde(rename = "boneIndex"))]
65 pub m_boneIndex: i16,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "animBoneIndex"))]
71 #[cfg_attr(feature = "serde", serde(rename = "animBoneIndex"))]
72 pub m_animBoneIndex: i16,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "isCloseToGround"))]
79 #[cfg_attr(feature = "serde", serde(rename = "isCloseToGround"))]
80 pub m_isCloseToGround: bool,
81}
82const _: () = {
83 use havok_serde as _serde;
84 impl<'a> _serde::HavokClass for hkbDetectCloseToGroundModifier<'a> {
85 #[inline]
86 fn name(&self) -> &'static str {
87 "hkbDetectCloseToGroundModifier"
88 }
89 #[inline]
90 fn signature(&self) -> _serde::__private::Signature {
91 _serde::__private::Signature::new(0x981687b2)
92 }
93 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
94 fn deps_indexes(&self) -> Vec<usize> {
95 let mut v = Vec::new();
96 v.push(self.parent.parent.parent.m_variableBindingSet.get());
97 v.extend(self.m_closeToGroundEvent.deps_indexes());
98 v
99 }
100 }
101 impl<'a> _serde::Serialize for hkbDetectCloseToGroundModifier<'a> {
102 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
103 where
104 S: _serde::ser::Serializer,
105 {
106 let class_meta = self
107 .__ptr
108 .map(|name| (name, _serde::__private::Signature::new(0x981687b2)));
109 let mut serializer = __serializer
110 .serialize_struct(
111 "hkbDetectCloseToGroundModifier",
112 class_meta,
113 (72u64, 120u64),
114 )?;
115 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
116 serializer
117 .skip_field(
118 "memSizeAndFlags",
119 &self.parent.parent.parent.parent.m_memSizeAndFlags,
120 )?;
121 serializer
122 .skip_field(
123 "referenceCount",
124 &self.parent.parent.parent.parent.m_referenceCount,
125 )?;
126 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
127 serializer
128 .serialize_field(
129 "variableBindingSet",
130 &self.parent.parent.parent.m_variableBindingSet,
131 )?;
132 serializer
133 .skip_array_field(
134 "cachedBindables",
135 &self.parent.parent.parent.m_cachedBindables,
136 TypeSize::NonPtr,
137 )?;
138 serializer
139 .skip_field(
140 "areBindablesCached",
141 &self.parent.parent.parent.m_areBindablesCached,
142 )?;
143 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
144 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
145 serializer.serialize_field("name", &self.parent.parent.m_name)?;
146 serializer.skip_field("id", &self.parent.parent.m_id)?;
147 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
148 serializer
149 .skip_fixed_array_field(
150 "padNode",
151 self.parent.parent.m_padNode.as_slice(),
152 TypeSize::NonPtr,
153 )?;
154 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
155 serializer.serialize_field("enable", &self.parent.m_enable)?;
156 serializer
157 .skip_fixed_array_field(
158 "padModifier",
159 self.parent.m_padModifier.as_slice(),
160 TypeSize::NonPtr,
161 )?;
162 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
163 serializer
164 .serialize_field("closeToGroundEvent", &self.m_closeToGroundEvent)?;
165 serializer
166 .serialize_field("closeToGroundHeight", &self.m_closeToGroundHeight)?;
167 serializer
168 .serialize_field("raycastDistanceDown", &self.m_raycastDistanceDown)?;
169 serializer
170 .serialize_field("collisionFilterInfo", &self.m_collisionFilterInfo)?;
171 serializer.serialize_field("boneIndex", &self.m_boneIndex)?;
172 serializer.serialize_field("animBoneIndex", &self.m_animBoneIndex)?;
173 serializer.skip_field("isCloseToGround", &self.m_isCloseToGround)?;
174 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
175 serializer.end()
176 }
177 }
178};
179#[doc(hidden)]
180#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
181const _: () = {
182 use havok_serde as _serde;
183 #[automatically_derived]
184 impl<'de> _serde::Deserialize<'de> for hkbDetectCloseToGroundModifier<'de> {
185 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
186 where
187 __D: _serde::Deserializer<'de>,
188 {
189 #[allow(non_camel_case_types)]
190 enum __Field {
191 m_variableBindingSet,
192 m_userData,
193 m_name,
194 m_enable,
195 m_closeToGroundEvent,
196 m_closeToGroundHeight,
197 m_raycastDistanceDown,
198 m_collisionFilterInfo,
199 m_boneIndex,
200 m_animBoneIndex,
201 __ignore,
202 }
203 struct __FieldVisitor;
204 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
205 type Value = __Field;
206 fn expecting(
207 &self,
208 __formatter: &mut core::fmt::Formatter,
209 ) -> core::fmt::Result {
210 core::fmt::Formatter::write_str(__formatter, "field identifier")
211 }
212 #[allow(clippy::match_single_binding)]
214 #[allow(clippy::reversed_empty_ranges)]
215 #[allow(clippy::single_match)]
216 fn visit_key<__E>(
217 self,
218 __value: &str,
219 ) -> core::result::Result<Self::Value, __E>
220 where
221 __E: _serde::de::Error,
222 {
223 match __value {
224 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
225 "userData" => Ok(__Field::m_userData),
226 "name" => Ok(__Field::m_name),
227 "enable" => Ok(__Field::m_enable),
228 "closeToGroundEvent" => Ok(__Field::m_closeToGroundEvent),
229 "closeToGroundHeight" => Ok(__Field::m_closeToGroundHeight),
230 "raycastDistanceDown" => Ok(__Field::m_raycastDistanceDown),
231 "collisionFilterInfo" => Ok(__Field::m_collisionFilterInfo),
232 "boneIndex" => Ok(__Field::m_boneIndex),
233 "animBoneIndex" => Ok(__Field::m_animBoneIndex),
234 _ => Ok(__Field::__ignore),
235 }
236 }
237 }
238 impl<'de> _serde::Deserialize<'de> for __Field {
239 #[inline]
240 fn deserialize<__D>(
241 __deserializer: __D,
242 ) -> core::result::Result<Self, __D::Error>
243 where
244 __D: _serde::Deserializer<'de>,
245 {
246 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
247 }
248 }
249 struct __hkbDetectCloseToGroundModifierVisitor<'de> {
250 marker: _serde::__private::PhantomData<
251 hkbDetectCloseToGroundModifier<'de>,
252 >,
253 lifetime: _serde::__private::PhantomData<&'de ()>,
254 }
255 #[allow(clippy::match_single_binding)]
256 #[allow(clippy::reversed_empty_ranges)]
257 #[allow(clippy::single_match)]
258 impl<'de> _serde::de::Visitor<'de>
259 for __hkbDetectCloseToGroundModifierVisitor<'de> {
260 type Value = hkbDetectCloseToGroundModifier<'de>;
261 fn expecting(
262 &self,
263 __formatter: &mut core::fmt::Formatter,
264 ) -> core::fmt::Result {
265 core::fmt::Formatter::write_str(
266 __formatter,
267 "struct hkbDetectCloseToGroundModifier",
268 )
269 }
270 fn visit_struct_for_bytes<__A>(
271 self,
272 mut __map: __A,
273 ) -> _serde::__private::Result<Self::Value, __A::Error>
274 where
275 __A: _serde::de::MapAccess<'de>,
276 {
277 let __ptr = __A::class_ptr(&mut __map);
278 let parent = __A::parent_value(&mut __map)?;
279 let mut m_closeToGroundEvent: _serde::__private::Option<
280 hkbEventProperty,
281 > = _serde::__private::None;
282 let mut m_closeToGroundHeight: _serde::__private::Option<f32> = _serde::__private::None;
283 let mut m_raycastDistanceDown: _serde::__private::Option<f32> = _serde::__private::None;
284 let mut m_collisionFilterInfo: _serde::__private::Option<u32> = _serde::__private::None;
285 let mut m_boneIndex: _serde::__private::Option<i16> = _serde::__private::None;
286 let mut m_animBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
287 let mut m_isCloseToGround: _serde::__private::Option<bool> = _serde::__private::None;
288 for i in 0..7usize {
289 match i {
290 0usize => {
291 if _serde::__private::Option::is_some(
292 &m_closeToGroundEvent,
293 ) {
294 return _serde::__private::Err(
295 <__A::Error as _serde::de::Error>::duplicate_field(
296 "closeToGroundEvent",
297 ),
298 );
299 }
300 m_closeToGroundEvent = _serde::__private::Some(
301 match __A::next_value::<hkbEventProperty>(&mut __map) {
302 _serde::__private::Ok(__val) => __val,
303 _serde::__private::Err(__err) => {
304 return _serde::__private::Err(__err);
305 }
306 },
307 );
308 }
309 1usize => {
310 if _serde::__private::Option::is_some(
311 &m_closeToGroundHeight,
312 ) {
313 return _serde::__private::Err(
314 <__A::Error as _serde::de::Error>::duplicate_field(
315 "closeToGroundHeight",
316 ),
317 );
318 }
319 m_closeToGroundHeight = _serde::__private::Some(
320 match __A::next_value::<f32>(&mut __map) {
321 _serde::__private::Ok(__val) => __val,
322 _serde::__private::Err(__err) => {
323 return _serde::__private::Err(__err);
324 }
325 },
326 );
327 }
328 2usize => {
329 if _serde::__private::Option::is_some(
330 &m_raycastDistanceDown,
331 ) {
332 return _serde::__private::Err(
333 <__A::Error as _serde::de::Error>::duplicate_field(
334 "raycastDistanceDown",
335 ),
336 );
337 }
338 m_raycastDistanceDown = _serde::__private::Some(
339 match __A::next_value::<f32>(&mut __map) {
340 _serde::__private::Ok(__val) => __val,
341 _serde::__private::Err(__err) => {
342 return _serde::__private::Err(__err);
343 }
344 },
345 );
346 }
347 3usize => {
348 if _serde::__private::Option::is_some(
349 &m_collisionFilterInfo,
350 ) {
351 return _serde::__private::Err(
352 <__A::Error as _serde::de::Error>::duplicate_field(
353 "collisionFilterInfo",
354 ),
355 );
356 }
357 m_collisionFilterInfo = _serde::__private::Some(
358 match __A::next_value::<u32>(&mut __map) {
359 _serde::__private::Ok(__val) => __val,
360 _serde::__private::Err(__err) => {
361 return _serde::__private::Err(__err);
362 }
363 },
364 );
365 }
366 4usize => {
367 if _serde::__private::Option::is_some(&m_boneIndex) {
368 return _serde::__private::Err(
369 <__A::Error as _serde::de::Error>::duplicate_field(
370 "boneIndex",
371 ),
372 );
373 }
374 m_boneIndex = _serde::__private::Some(
375 match __A::next_value::<i16>(&mut __map) {
376 _serde::__private::Ok(__val) => __val,
377 _serde::__private::Err(__err) => {
378 return _serde::__private::Err(__err);
379 }
380 },
381 );
382 }
383 5usize => {
384 if _serde::__private::Option::is_some(&m_animBoneIndex) {
385 return _serde::__private::Err(
386 <__A::Error as _serde::de::Error>::duplicate_field(
387 "animBoneIndex",
388 ),
389 );
390 }
391 m_animBoneIndex = _serde::__private::Some(
392 match __A::next_value::<i16>(&mut __map) {
393 _serde::__private::Ok(__val) => __val,
394 _serde::__private::Err(__err) => {
395 return _serde::__private::Err(__err);
396 }
397 },
398 );
399 }
400 6usize => {
401 if _serde::__private::Option::is_some(&m_isCloseToGround) {
402 return _serde::__private::Err(
403 <__A::Error as _serde::de::Error>::duplicate_field(
404 "isCloseToGround",
405 ),
406 );
407 }
408 m_isCloseToGround = _serde::__private::Some(
409 match __A::next_value::<bool>(&mut __map) {
410 _serde::__private::Ok(__val) => __val,
411 _serde::__private::Err(__err) => {
412 return _serde::__private::Err(__err);
413 }
414 },
415 );
416 }
417 _ => {}
418 }
419 }
420 __A::pad(&mut __map, 3usize, 7usize)?;
421 let m_closeToGroundEvent = match m_closeToGroundEvent {
422 _serde::__private::Some(__field) => __field,
423 _serde::__private::None => {
424 return _serde::__private::Err(
425 <__A::Error as _serde::de::Error>::missing_field(
426 "closeToGroundEvent",
427 ),
428 );
429 }
430 };
431 let m_closeToGroundHeight = match m_closeToGroundHeight {
432 _serde::__private::Some(__field) => __field,
433 _serde::__private::None => {
434 return _serde::__private::Err(
435 <__A::Error as _serde::de::Error>::missing_field(
436 "closeToGroundHeight",
437 ),
438 );
439 }
440 };
441 let m_raycastDistanceDown = match m_raycastDistanceDown {
442 _serde::__private::Some(__field) => __field,
443 _serde::__private::None => {
444 return _serde::__private::Err(
445 <__A::Error as _serde::de::Error>::missing_field(
446 "raycastDistanceDown",
447 ),
448 );
449 }
450 };
451 let m_collisionFilterInfo = match m_collisionFilterInfo {
452 _serde::__private::Some(__field) => __field,
453 _serde::__private::None => {
454 return _serde::__private::Err(
455 <__A::Error as _serde::de::Error>::missing_field(
456 "collisionFilterInfo",
457 ),
458 );
459 }
460 };
461 let m_boneIndex = match m_boneIndex {
462 _serde::__private::Some(__field) => __field,
463 _serde::__private::None => {
464 return _serde::__private::Err(
465 <__A::Error as _serde::de::Error>::missing_field(
466 "boneIndex",
467 ),
468 );
469 }
470 };
471 let m_animBoneIndex = match m_animBoneIndex {
472 _serde::__private::Some(__field) => __field,
473 _serde::__private::None => {
474 return _serde::__private::Err(
475 <__A::Error as _serde::de::Error>::missing_field(
476 "animBoneIndex",
477 ),
478 );
479 }
480 };
481 let m_isCloseToGround = match m_isCloseToGround {
482 _serde::__private::Some(__field) => __field,
483 _serde::__private::None => {
484 return _serde::__private::Err(
485 <__A::Error as _serde::de::Error>::missing_field(
486 "isCloseToGround",
487 ),
488 );
489 }
490 };
491 _serde::__private::Ok(hkbDetectCloseToGroundModifier {
492 __ptr,
493 parent,
494 m_closeToGroundEvent,
495 m_closeToGroundHeight,
496 m_raycastDistanceDown,
497 m_collisionFilterInfo,
498 m_boneIndex,
499 m_animBoneIndex,
500 m_isCloseToGround,
501 })
502 }
503 #[allow(clippy::manual_unwrap_or_default)]
504 fn visit_struct<__A>(
505 self,
506 mut __map: __A,
507 ) -> _serde::__private::Result<Self::Value, __A::Error>
508 where
509 __A: _serde::de::MapAccess<'de>,
510 {
511 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
512 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
513 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
514 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
515 let mut m_closeToGroundEvent: _serde::__private::Option<
516 hkbEventProperty,
517 > = _serde::__private::None;
518 let mut m_closeToGroundHeight: _serde::__private::Option<f32> = _serde::__private::None;
519 let mut m_raycastDistanceDown: _serde::__private::Option<f32> = _serde::__private::None;
520 let mut m_collisionFilterInfo: _serde::__private::Option<u32> = _serde::__private::None;
521 let mut m_boneIndex: _serde::__private::Option<i16> = _serde::__private::None;
522 let mut m_animBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
523 while let _serde::__private::Some(__key) = {
524 __A::next_key::<__Field>(&mut __map)?
525 } {
526 match __key {
527 __Field::m_variableBindingSet => {
528 #[cfg(
529 any(feature = "strict", feature = "ignore_duplicates")
530 )]
531 if _serde::__private::Option::is_some(
532 &m_variableBindingSet,
533 ) {
534 #[cfg(feature = "ignore_duplicates")]
535 {
536 __A::skip_value(&mut __map)?;
537 continue;
538 }
539 #[cfg(feature = "strict")]
540 return _serde::__private::Err(
541 <__A::Error as _serde::de::Error>::duplicate_field(
542 "variableBindingSet",
543 ),
544 );
545 }
546 m_variableBindingSet = _serde::__private::Some(
547 match __A::next_value::<Pointer>(&mut __map) {
548 _serde::__private::Ok(__val) => __val,
549 _serde::__private::Err(__err) => {
550 return _serde::__private::Err(__err);
551 }
552 },
553 );
554 }
555 __Field::m_userData => {
556 #[cfg(
557 any(feature = "strict", feature = "ignore_duplicates")
558 )]
559 if _serde::__private::Option::is_some(&m_userData) {
560 #[cfg(feature = "ignore_duplicates")]
561 {
562 __A::skip_value(&mut __map)?;
563 continue;
564 }
565 #[cfg(feature = "strict")]
566 return _serde::__private::Err(
567 <__A::Error as _serde::de::Error>::duplicate_field(
568 "userData",
569 ),
570 );
571 }
572 m_userData = _serde::__private::Some(
573 match __A::next_value::<Ulong>(&mut __map) {
574 _serde::__private::Ok(__val) => __val,
575 _serde::__private::Err(__err) => {
576 return _serde::__private::Err(__err);
577 }
578 },
579 );
580 }
581 __Field::m_name => {
582 #[cfg(
583 any(feature = "strict", feature = "ignore_duplicates")
584 )]
585 if _serde::__private::Option::is_some(&m_name) {
586 #[cfg(feature = "ignore_duplicates")]
587 {
588 __A::skip_value(&mut __map)?;
589 continue;
590 }
591 #[cfg(feature = "strict")]
592 return _serde::__private::Err(
593 <__A::Error as _serde::de::Error>::duplicate_field("name"),
594 );
595 }
596 m_name = _serde::__private::Some(
597 match __A::next_value::<StringPtr<'de>>(&mut __map) {
598 _serde::__private::Ok(__val) => __val,
599 _serde::__private::Err(__err) => {
600 return _serde::__private::Err(__err);
601 }
602 },
603 );
604 }
605 __Field::m_enable => {
606 #[cfg(
607 any(feature = "strict", feature = "ignore_duplicates")
608 )]
609 if _serde::__private::Option::is_some(&m_enable) {
610 #[cfg(feature = "ignore_duplicates")]
611 {
612 __A::skip_value(&mut __map)?;
613 continue;
614 }
615 #[cfg(feature = "strict")]
616 return _serde::__private::Err(
617 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
618 );
619 }
620 m_enable = _serde::__private::Some(
621 match __A::next_value::<bool>(&mut __map) {
622 _serde::__private::Ok(__val) => __val,
623 _serde::__private::Err(__err) => {
624 return _serde::__private::Err(__err);
625 }
626 },
627 );
628 }
629 __Field::m_closeToGroundEvent => {
630 #[cfg(
631 any(feature = "strict", feature = "ignore_duplicates")
632 )]
633 if _serde::__private::Option::is_some(
634 &m_closeToGroundEvent,
635 ) {
636 #[cfg(feature = "ignore_duplicates")]
637 {
638 __A::skip_value(&mut __map)?;
639 continue;
640 }
641 #[cfg(feature = "strict")]
642 return _serde::__private::Err(
643 <__A::Error as _serde::de::Error>::duplicate_field(
644 "closeToGroundEvent",
645 ),
646 );
647 }
648 m_closeToGroundEvent = _serde::__private::Some(
649 match __A::next_value::<hkbEventProperty>(&mut __map) {
650 _serde::__private::Ok(__val) => __val,
651 _serde::__private::Err(__err) => {
652 return _serde::__private::Err(__err);
653 }
654 },
655 );
656 }
657 __Field::m_closeToGroundHeight => {
658 #[cfg(
659 any(feature = "strict", feature = "ignore_duplicates")
660 )]
661 if _serde::__private::Option::is_some(
662 &m_closeToGroundHeight,
663 ) {
664 #[cfg(feature = "ignore_duplicates")]
665 {
666 __A::skip_value(&mut __map)?;
667 continue;
668 }
669 #[cfg(feature = "strict")]
670 return _serde::__private::Err(
671 <__A::Error as _serde::de::Error>::duplicate_field(
672 "closeToGroundHeight",
673 ),
674 );
675 }
676 m_closeToGroundHeight = _serde::__private::Some(
677 match __A::next_value::<f32>(&mut __map) {
678 _serde::__private::Ok(__val) => __val,
679 _serde::__private::Err(__err) => {
680 return _serde::__private::Err(__err);
681 }
682 },
683 );
684 }
685 __Field::m_raycastDistanceDown => {
686 #[cfg(
687 any(feature = "strict", feature = "ignore_duplicates")
688 )]
689 if _serde::__private::Option::is_some(
690 &m_raycastDistanceDown,
691 ) {
692 #[cfg(feature = "ignore_duplicates")]
693 {
694 __A::skip_value(&mut __map)?;
695 continue;
696 }
697 #[cfg(feature = "strict")]
698 return _serde::__private::Err(
699 <__A::Error as _serde::de::Error>::duplicate_field(
700 "raycastDistanceDown",
701 ),
702 );
703 }
704 m_raycastDistanceDown = _serde::__private::Some(
705 match __A::next_value::<f32>(&mut __map) {
706 _serde::__private::Ok(__val) => __val,
707 _serde::__private::Err(__err) => {
708 return _serde::__private::Err(__err);
709 }
710 },
711 );
712 }
713 __Field::m_collisionFilterInfo => {
714 #[cfg(
715 any(feature = "strict", feature = "ignore_duplicates")
716 )]
717 if _serde::__private::Option::is_some(
718 &m_collisionFilterInfo,
719 ) {
720 #[cfg(feature = "ignore_duplicates")]
721 {
722 __A::skip_value(&mut __map)?;
723 continue;
724 }
725 #[cfg(feature = "strict")]
726 return _serde::__private::Err(
727 <__A::Error as _serde::de::Error>::duplicate_field(
728 "collisionFilterInfo",
729 ),
730 );
731 }
732 m_collisionFilterInfo = _serde::__private::Some(
733 match __A::next_value::<u32>(&mut __map) {
734 _serde::__private::Ok(__val) => __val,
735 _serde::__private::Err(__err) => {
736 return _serde::__private::Err(__err);
737 }
738 },
739 );
740 }
741 __Field::m_boneIndex => {
742 #[cfg(
743 any(feature = "strict", feature = "ignore_duplicates")
744 )]
745 if _serde::__private::Option::is_some(&m_boneIndex) {
746 #[cfg(feature = "ignore_duplicates")]
747 {
748 __A::skip_value(&mut __map)?;
749 continue;
750 }
751 #[cfg(feature = "strict")]
752 return _serde::__private::Err(
753 <__A::Error as _serde::de::Error>::duplicate_field(
754 "boneIndex",
755 ),
756 );
757 }
758 m_boneIndex = _serde::__private::Some(
759 match __A::next_value::<i16>(&mut __map) {
760 _serde::__private::Ok(__val) => __val,
761 _serde::__private::Err(__err) => {
762 return _serde::__private::Err(__err);
763 }
764 },
765 );
766 }
767 __Field::m_animBoneIndex => {
768 #[cfg(
769 any(feature = "strict", feature = "ignore_duplicates")
770 )]
771 if _serde::__private::Option::is_some(&m_animBoneIndex) {
772 #[cfg(feature = "ignore_duplicates")]
773 {
774 __A::skip_value(&mut __map)?;
775 continue;
776 }
777 #[cfg(feature = "strict")]
778 return _serde::__private::Err(
779 <__A::Error as _serde::de::Error>::duplicate_field(
780 "animBoneIndex",
781 ),
782 );
783 }
784 m_animBoneIndex = _serde::__private::Some(
785 match __A::next_value::<i16>(&mut __map) {
786 _serde::__private::Ok(__val) => __val,
787 _serde::__private::Err(__err) => {
788 return _serde::__private::Err(__err);
789 }
790 },
791 );
792 }
793 _ => __A::skip_value(&mut __map)?,
794 }
795 }
796 let m_variableBindingSet = match m_variableBindingSet {
797 _serde::__private::Some(__field) => __field,
798 _serde::__private::None => {
799 #[cfg(feature = "strict")]
800 return _serde::__private::Err(
801 <__A::Error as _serde::de::Error>::missing_field(
802 "variableBindingSet",
803 ),
804 );
805 #[cfg(not(feature = "strict"))] Default::default()
806 }
807 };
808 let m_userData = match m_userData {
809 _serde::__private::Some(__field) => __field,
810 _serde::__private::None => {
811 #[cfg(feature = "strict")]
812 return _serde::__private::Err(
813 <__A::Error as _serde::de::Error>::missing_field("userData"),
814 );
815 #[cfg(not(feature = "strict"))] Default::default()
816 }
817 };
818 let m_name = match m_name {
819 _serde::__private::Some(__field) => __field,
820 _serde::__private::None => {
821 #[cfg(feature = "strict")]
822 return _serde::__private::Err(
823 <__A::Error as _serde::de::Error>::missing_field("name"),
824 );
825 #[cfg(not(feature = "strict"))] Default::default()
826 }
827 };
828 let m_enable = match m_enable {
829 _serde::__private::Some(__field) => __field,
830 _serde::__private::None => {
831 #[cfg(feature = "strict")]
832 return _serde::__private::Err(
833 <__A::Error as _serde::de::Error>::missing_field("enable"),
834 );
835 #[cfg(not(feature = "strict"))] Default::default()
836 }
837 };
838 let m_closeToGroundEvent = match m_closeToGroundEvent {
839 _serde::__private::Some(__field) => __field,
840 _serde::__private::None => {
841 #[cfg(feature = "strict")]
842 return _serde::__private::Err(
843 <__A::Error as _serde::de::Error>::missing_field(
844 "closeToGroundEvent",
845 ),
846 );
847 #[cfg(not(feature = "strict"))] Default::default()
848 }
849 };
850 let m_closeToGroundHeight = match m_closeToGroundHeight {
851 _serde::__private::Some(__field) => __field,
852 _serde::__private::None => {
853 #[cfg(feature = "strict")]
854 return _serde::__private::Err(
855 <__A::Error as _serde::de::Error>::missing_field(
856 "closeToGroundHeight",
857 ),
858 );
859 #[cfg(not(feature = "strict"))] Default::default()
860 }
861 };
862 let m_raycastDistanceDown = match m_raycastDistanceDown {
863 _serde::__private::Some(__field) => __field,
864 _serde::__private::None => {
865 #[cfg(feature = "strict")]
866 return _serde::__private::Err(
867 <__A::Error as _serde::de::Error>::missing_field(
868 "raycastDistanceDown",
869 ),
870 );
871 #[cfg(not(feature = "strict"))] Default::default()
872 }
873 };
874 let m_collisionFilterInfo = match m_collisionFilterInfo {
875 _serde::__private::Some(__field) => __field,
876 _serde::__private::None => {
877 #[cfg(feature = "strict")]
878 return _serde::__private::Err(
879 <__A::Error as _serde::de::Error>::missing_field(
880 "collisionFilterInfo",
881 ),
882 );
883 #[cfg(not(feature = "strict"))] Default::default()
884 }
885 };
886 let m_boneIndex = match m_boneIndex {
887 _serde::__private::Some(__field) => __field,
888 _serde::__private::None => {
889 #[cfg(feature = "strict")]
890 return _serde::__private::Err(
891 <__A::Error as _serde::de::Error>::missing_field(
892 "boneIndex",
893 ),
894 );
895 #[cfg(not(feature = "strict"))] Default::default()
896 }
897 };
898 let m_animBoneIndex = match m_animBoneIndex {
899 _serde::__private::Some(__field) => __field,
900 _serde::__private::None => {
901 #[cfg(feature = "strict")]
902 return _serde::__private::Err(
903 <__A::Error as _serde::de::Error>::missing_field(
904 "animBoneIndex",
905 ),
906 );
907 #[cfg(not(feature = "strict"))] Default::default()
908 }
909 };
910 let __ptr = None;
911 let parent = hkBaseObject { __ptr };
912 let parent = hkReferencedObject {
913 __ptr,
914 parent,
915 ..Default::default()
916 };
917 let parent = hkbBindable {
918 __ptr,
919 parent,
920 m_variableBindingSet,
921 ..Default::default()
922 };
923 let parent = hkbNode {
924 __ptr,
925 parent,
926 m_userData,
927 m_name,
928 ..Default::default()
929 };
930 let parent = hkbModifier {
931 __ptr,
932 parent,
933 m_enable,
934 ..Default::default()
935 };
936 let __ptr = __A::class_ptr(&mut __map);
937 _serde::__private::Ok(hkbDetectCloseToGroundModifier {
938 __ptr,
939 parent,
940 m_closeToGroundEvent,
941 m_closeToGroundHeight,
942 m_raycastDistanceDown,
943 m_collisionFilterInfo,
944 m_boneIndex,
945 m_animBoneIndex,
946 ..Default::default()
947 })
948 }
949 }
950 const FIELDS: &[&str] = &[
951 "closeToGroundEvent",
952 "closeToGroundHeight",
953 "raycastDistanceDown",
954 "collisionFilterInfo",
955 "boneIndex",
956 "animBoneIndex",
957 "isCloseToGround",
958 ];
959 _serde::Deserializer::deserialize_struct(
960 deserializer,
961 "hkbDetectCloseToGroundModifier",
962 FIELDS,
963 __hkbDetectCloseToGroundModifierVisitor {
964 marker: _serde::__private::PhantomData::<
965 hkbDetectCloseToGroundModifier,
966 >,
967 lifetime: _serde::__private::PhantomData,
968 },
969 )
970 }
971 }
972};