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 hkbSenseHandleModifier<'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 = "handle"))]
37 #[cfg_attr(feature = "serde", serde(rename = "handle"))]
38 pub m_handle: hkbHandle,
39 #[cfg_attr(feature = "json_schema", schemars(rename = "sensorLocalOffset"))]
44 #[cfg_attr(feature = "serde", serde(rename = "sensorLocalOffset"))]
45 pub m_sensorLocalOffset: Vector4,
46 #[cfg_attr(feature = "json_schema", schemars(rename = "ranges"))]
51 #[cfg_attr(feature = "serde", serde(rename = "ranges"))]
52 pub m_ranges: Vec<hkbSenseHandleModifierRange>,
53 #[cfg_attr(feature = "json_schema", schemars(rename = "handleOut"))]
58 #[cfg_attr(feature = "serde", serde(rename = "handleOut"))]
59 pub m_handleOut: Pointer,
60 #[cfg_attr(feature = "json_schema", schemars(rename = "handleIn"))]
65 #[cfg_attr(feature = "serde", serde(rename = "handleIn"))]
66 pub m_handleIn: Pointer,
67 #[cfg_attr(feature = "serde", serde(borrow))]
72 #[cfg_attr(feature = "json_schema", schemars(rename = "localFrameName"))]
73 #[cfg_attr(feature = "serde", serde(rename = "localFrameName"))]
74 pub m_localFrameName: StringPtr<'a>,
75 #[cfg_attr(feature = "serde", serde(borrow))]
80 #[cfg_attr(feature = "json_schema", schemars(rename = "sensorLocalFrameName"))]
81 #[cfg_attr(feature = "serde", serde(rename = "sensorLocalFrameName"))]
82 pub m_sensorLocalFrameName: StringPtr<'a>,
83 #[cfg_attr(feature = "json_schema", schemars(rename = "minDistance"))]
88 #[cfg_attr(feature = "serde", serde(rename = "minDistance"))]
89 pub m_minDistance: f32,
90 #[cfg_attr(feature = "json_schema", schemars(rename = "maxDistance"))]
95 #[cfg_attr(feature = "serde", serde(rename = "maxDistance"))]
96 pub m_maxDistance: f32,
97 #[cfg_attr(feature = "json_schema", schemars(rename = "distanceOut"))]
102 #[cfg_attr(feature = "serde", serde(rename = "distanceOut"))]
103 pub m_distanceOut: f32,
104 #[cfg_attr(feature = "json_schema", schemars(rename = "collisionFilterInfo"))]
109 #[cfg_attr(feature = "serde", serde(rename = "collisionFilterInfo"))]
110 pub m_collisionFilterInfo: u32,
111 #[cfg_attr(feature = "json_schema", schemars(rename = "sensorRagdollBoneIndex"))]
116 #[cfg_attr(feature = "serde", serde(rename = "sensorRagdollBoneIndex"))]
117 pub m_sensorRagdollBoneIndex: i16,
118 #[cfg_attr(feature = "json_schema", schemars(rename = "sensorAnimationBoneIndex"))]
123 #[cfg_attr(feature = "serde", serde(rename = "sensorAnimationBoneIndex"))]
124 pub m_sensorAnimationBoneIndex: i16,
125 #[cfg_attr(feature = "json_schema", schemars(rename = "sensingMode"))]
130 #[cfg_attr(feature = "serde", serde(rename = "sensingMode"))]
131 pub m_sensingMode: SensingMode,
132 #[cfg_attr(feature = "json_schema", schemars(rename = "extrapolateSensorPosition"))]
137 #[cfg_attr(feature = "serde", serde(rename = "extrapolateSensorPosition"))]
138 pub m_extrapolateSensorPosition: bool,
139 #[cfg_attr(feature = "json_schema", schemars(rename = "keepFirstSensedHandle"))]
144 #[cfg_attr(feature = "serde", serde(rename = "keepFirstSensedHandle"))]
145 pub m_keepFirstSensedHandle: bool,
146 #[cfg_attr(feature = "json_schema", schemars(rename = "foundHandleOut"))]
151 #[cfg_attr(feature = "serde", serde(rename = "foundHandleOut"))]
152 pub m_foundHandleOut: bool,
153 #[cfg_attr(feature = "json_schema", schemars(rename = "timeSinceLastModify"))]
159 #[cfg_attr(feature = "serde", serde(rename = "timeSinceLastModify"))]
160 pub m_timeSinceLastModify: f32,
161 #[cfg_attr(
167 feature = "json_schema",
168 schemars(rename = "rangeIndexForEventToSendNextUpdate")
169 )]
170 #[cfg_attr(feature = "serde", serde(rename = "rangeIndexForEventToSendNextUpdate"))]
171 pub m_rangeIndexForEventToSendNextUpdate: i32,
172}
173const _: () = {
174 use havok_serde as _serde;
175 impl<'a> _serde::HavokClass for hkbSenseHandleModifier<'a> {
176 #[inline]
177 fn name(&self) -> &'static str {
178 "hkbSenseHandleModifier"
179 }
180 #[inline]
181 fn signature(&self) -> _serde::__private::Signature {
182 _serde::__private::Signature::new(0x2a064d99)
183 }
184 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
185 fn deps_indexes(&self) -> Vec<usize> {
186 let mut v = Vec::new();
187 v.push(self.parent.parent.parent.m_variableBindingSet.get());
188 v.extend(self.m_handle.deps_indexes());
189 v.extend(
190 self
191 .m_ranges
192 .iter()
193 .flat_map(|class| class.deps_indexes())
194 .collect::<Vec<usize>>(),
195 );
196 v.push(self.m_handleOut.get());
197 v.push(self.m_handleIn.get());
198 v
199 }
200 }
201 impl<'a> _serde::Serialize for hkbSenseHandleModifier<'a> {
202 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
203 where
204 S: _serde::ser::Serializer,
205 {
206 let class_meta = self
207 .__ptr
208 .map(|name| (name, _serde::__private::Signature::new(0x2a064d99)));
209 let mut serializer = __serializer
210 .serialize_struct(
211 "hkbSenseHandleModifier",
212 class_meta,
213 (160u64, 224u64),
214 )?;
215 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
216 serializer
217 .skip_field(
218 "memSizeAndFlags",
219 &self.parent.parent.parent.parent.m_memSizeAndFlags,
220 )?;
221 serializer
222 .skip_field(
223 "referenceCount",
224 &self.parent.parent.parent.parent.m_referenceCount,
225 )?;
226 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
227 serializer
228 .serialize_field(
229 "variableBindingSet",
230 &self.parent.parent.parent.m_variableBindingSet,
231 )?;
232 serializer
233 .skip_array_field(
234 "cachedBindables",
235 &self.parent.parent.parent.m_cachedBindables,
236 TypeSize::NonPtr,
237 )?;
238 serializer
239 .skip_field(
240 "areBindablesCached",
241 &self.parent.parent.parent.m_areBindablesCached,
242 )?;
243 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
244 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
245 serializer.serialize_field("name", &self.parent.parent.m_name)?;
246 serializer.skip_field("id", &self.parent.parent.m_id)?;
247 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
248 serializer
249 .skip_fixed_array_field(
250 "padNode",
251 self.parent.parent.m_padNode.as_slice(),
252 TypeSize::NonPtr,
253 )?;
254 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
255 serializer.serialize_field("enable", &self.parent.m_enable)?;
256 serializer
257 .skip_fixed_array_field(
258 "padModifier",
259 self.parent.m_padModifier.as_slice(),
260 TypeSize::NonPtr,
261 )?;
262 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
263 serializer.skip_field("handle", &self.m_handle)?;
264 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 0usize].as_slice())?;
265 serializer.serialize_field("sensorLocalOffset", &self.m_sensorLocalOffset)?;
266 serializer
267 .serialize_array_field(
268 "ranges",
269 &self.m_ranges,
270 TypeSize::Struct {
271 size_x86: 20u64,
272 size_x86_64: 32u64,
273 },
274 )?;
275 serializer.serialize_field("handleOut", &self.m_handleOut)?;
276 serializer.serialize_field("handleIn", &self.m_handleIn)?;
277 serializer.serialize_field("localFrameName", &self.m_localFrameName)?;
278 serializer
279 .serialize_field("sensorLocalFrameName", &self.m_sensorLocalFrameName)?;
280 serializer.serialize_field("minDistance", &self.m_minDistance)?;
281 serializer.serialize_field("maxDistance", &self.m_maxDistance)?;
282 serializer.serialize_field("distanceOut", &self.m_distanceOut)?;
283 serializer
284 .serialize_field("collisionFilterInfo", &self.m_collisionFilterInfo)?;
285 serializer
286 .serialize_field(
287 "sensorRagdollBoneIndex",
288 &self.m_sensorRagdollBoneIndex,
289 )?;
290 serializer
291 .serialize_field(
292 "sensorAnimationBoneIndex",
293 &self.m_sensorAnimationBoneIndex,
294 )?;
295 serializer.serialize_field("sensingMode", &self.m_sensingMode)?;
296 serializer
297 .serialize_field(
298 "extrapolateSensorPosition",
299 &self.m_extrapolateSensorPosition,
300 )?;
301 serializer
302 .serialize_field(
303 "keepFirstSensedHandle",
304 &self.m_keepFirstSensedHandle,
305 )?;
306 serializer.serialize_field("foundHandleOut", &self.m_foundHandleOut)?;
307 serializer.skip_field("timeSinceLastModify", &self.m_timeSinceLastModify)?;
308 serializer
309 .skip_field(
310 "rangeIndexForEventToSendNextUpdate",
311 &self.m_rangeIndexForEventToSendNextUpdate,
312 )?;
313 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
314 serializer.end()
315 }
316 }
317};
318#[doc(hidden)]
319#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
320const _: () = {
321 use havok_serde as _serde;
322 #[automatically_derived]
323 impl<'de> _serde::Deserialize<'de> for hkbSenseHandleModifier<'de> {
324 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
325 where
326 __D: _serde::Deserializer<'de>,
327 {
328 #[allow(non_camel_case_types)]
329 enum __Field {
330 m_variableBindingSet,
331 m_userData,
332 m_name,
333 m_enable,
334 m_sensorLocalOffset,
335 m_ranges,
336 m_handleOut,
337 m_handleIn,
338 m_localFrameName,
339 m_sensorLocalFrameName,
340 m_minDistance,
341 m_maxDistance,
342 m_distanceOut,
343 m_collisionFilterInfo,
344 m_sensorRagdollBoneIndex,
345 m_sensorAnimationBoneIndex,
346 m_sensingMode,
347 m_extrapolateSensorPosition,
348 m_keepFirstSensedHandle,
349 m_foundHandleOut,
350 __ignore,
351 }
352 struct __FieldVisitor;
353 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
354 type Value = __Field;
355 fn expecting(
356 &self,
357 __formatter: &mut core::fmt::Formatter,
358 ) -> core::fmt::Result {
359 core::fmt::Formatter::write_str(__formatter, "field identifier")
360 }
361 #[allow(clippy::match_single_binding)]
363 #[allow(clippy::reversed_empty_ranges)]
364 #[allow(clippy::single_match)]
365 fn visit_key<__E>(
366 self,
367 __value: &str,
368 ) -> core::result::Result<Self::Value, __E>
369 where
370 __E: _serde::de::Error,
371 {
372 match __value {
373 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
374 "userData" => Ok(__Field::m_userData),
375 "name" => Ok(__Field::m_name),
376 "enable" => Ok(__Field::m_enable),
377 "sensorLocalOffset" => Ok(__Field::m_sensorLocalOffset),
378 "ranges" => Ok(__Field::m_ranges),
379 "handleOut" => Ok(__Field::m_handleOut),
380 "handleIn" => Ok(__Field::m_handleIn),
381 "localFrameName" => Ok(__Field::m_localFrameName),
382 "sensorLocalFrameName" => Ok(__Field::m_sensorLocalFrameName),
383 "minDistance" => Ok(__Field::m_minDistance),
384 "maxDistance" => Ok(__Field::m_maxDistance),
385 "distanceOut" => Ok(__Field::m_distanceOut),
386 "collisionFilterInfo" => Ok(__Field::m_collisionFilterInfo),
387 "sensorRagdollBoneIndex" => Ok(__Field::m_sensorRagdollBoneIndex),
388 "sensorAnimationBoneIndex" => {
389 Ok(__Field::m_sensorAnimationBoneIndex)
390 }
391 "sensingMode" => Ok(__Field::m_sensingMode),
392 "extrapolateSensorPosition" => {
393 Ok(__Field::m_extrapolateSensorPosition)
394 }
395 "keepFirstSensedHandle" => Ok(__Field::m_keepFirstSensedHandle),
396 "foundHandleOut" => Ok(__Field::m_foundHandleOut),
397 _ => Ok(__Field::__ignore),
398 }
399 }
400 }
401 impl<'de> _serde::Deserialize<'de> for __Field {
402 #[inline]
403 fn deserialize<__D>(
404 __deserializer: __D,
405 ) -> core::result::Result<Self, __D::Error>
406 where
407 __D: _serde::Deserializer<'de>,
408 {
409 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
410 }
411 }
412 struct __hkbSenseHandleModifierVisitor<'de> {
413 marker: _serde::__private::PhantomData<hkbSenseHandleModifier<'de>>,
414 lifetime: _serde::__private::PhantomData<&'de ()>,
415 }
416 #[allow(clippy::match_single_binding)]
417 #[allow(clippy::reversed_empty_ranges)]
418 #[allow(clippy::single_match)]
419 impl<'de> _serde::de::Visitor<'de> for __hkbSenseHandleModifierVisitor<'de> {
420 type Value = hkbSenseHandleModifier<'de>;
421 fn expecting(
422 &self,
423 __formatter: &mut core::fmt::Formatter,
424 ) -> core::fmt::Result {
425 core::fmt::Formatter::write_str(
426 __formatter,
427 "struct hkbSenseHandleModifier",
428 )
429 }
430 fn visit_struct_for_bytes<__A>(
431 self,
432 mut __map: __A,
433 ) -> _serde::__private::Result<Self::Value, __A::Error>
434 where
435 __A: _serde::de::MapAccess<'de>,
436 {
437 let __ptr = __A::class_ptr(&mut __map);
438 let parent = __A::parent_value(&mut __map)?;
439 let mut m_handle: _serde::__private::Option<hkbHandle> = _serde::__private::None;
440 let mut m_sensorLocalOffset: _serde::__private::Option<Vector4> = _serde::__private::None;
441 let mut m_ranges: _serde::__private::Option<
442 Vec<hkbSenseHandleModifierRange>,
443 > = _serde::__private::None;
444 let mut m_handleOut: _serde::__private::Option<Pointer> = _serde::__private::None;
445 let mut m_handleIn: _serde::__private::Option<Pointer> = _serde::__private::None;
446 let mut m_localFrameName: _serde::__private::Option<
447 StringPtr<'de>,
448 > = _serde::__private::None;
449 let mut m_sensorLocalFrameName: _serde::__private::Option<
450 StringPtr<'de>,
451 > = _serde::__private::None;
452 let mut m_minDistance: _serde::__private::Option<f32> = _serde::__private::None;
453 let mut m_maxDistance: _serde::__private::Option<f32> = _serde::__private::None;
454 let mut m_distanceOut: _serde::__private::Option<f32> = _serde::__private::None;
455 let mut m_collisionFilterInfo: _serde::__private::Option<u32> = _serde::__private::None;
456 let mut m_sensorRagdollBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
457 let mut m_sensorAnimationBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
458 let mut m_sensingMode: _serde::__private::Option<SensingMode> = _serde::__private::None;
459 let mut m_extrapolateSensorPosition: _serde::__private::Option<
460 bool,
461 > = _serde::__private::None;
462 let mut m_keepFirstSensedHandle: _serde::__private::Option<bool> = _serde::__private::None;
463 let mut m_foundHandleOut: _serde::__private::Option<bool> = _serde::__private::None;
464 let mut m_timeSinceLastModify: _serde::__private::Option<f32> = _serde::__private::None;
465 let mut m_rangeIndexForEventToSendNextUpdate: _serde::__private::Option<
466 i32,
467 > = _serde::__private::None;
468 for i in 0..19usize {
469 match i {
470 0usize => {
471 if _serde::__private::Option::is_some(&m_handle) {
472 return _serde::__private::Err(
473 <__A::Error as _serde::de::Error>::duplicate_field("handle"),
474 );
475 }
476 m_handle = _serde::__private::Some(
477 match __A::next_value::<hkbHandle>(&mut __map) {
478 _serde::__private::Ok(__val) => __val,
479 _serde::__private::Err(__err) => {
480 return _serde::__private::Err(__err);
481 }
482 },
483 );
484 }
485 1usize => {
486 if _serde::__private::Option::is_some(
487 &m_sensorLocalOffset,
488 ) {
489 return _serde::__private::Err(
490 <__A::Error as _serde::de::Error>::duplicate_field(
491 "sensorLocalOffset",
492 ),
493 );
494 }
495 __A::pad(&mut __map, 12usize, 0usize)?;
496 m_sensorLocalOffset = _serde::__private::Some(
497 match __A::next_value::<Vector4>(&mut __map) {
498 _serde::__private::Ok(__val) => __val,
499 _serde::__private::Err(__err) => {
500 return _serde::__private::Err(__err);
501 }
502 },
503 );
504 }
505 2usize => {
506 if _serde::__private::Option::is_some(&m_ranges) {
507 return _serde::__private::Err(
508 <__A::Error as _serde::de::Error>::duplicate_field("ranges"),
509 );
510 }
511 m_ranges = _serde::__private::Some(
512 match __A::next_value::<
513 Vec<hkbSenseHandleModifierRange>,
514 >(&mut __map) {
515 _serde::__private::Ok(__val) => __val,
516 _serde::__private::Err(__err) => {
517 return _serde::__private::Err(__err);
518 }
519 },
520 );
521 }
522 3usize => {
523 if _serde::__private::Option::is_some(&m_handleOut) {
524 return _serde::__private::Err(
525 <__A::Error as _serde::de::Error>::duplicate_field(
526 "handleOut",
527 ),
528 );
529 }
530 m_handleOut = _serde::__private::Some(
531 match __A::next_value::<Pointer>(&mut __map) {
532 _serde::__private::Ok(__val) => __val,
533 _serde::__private::Err(__err) => {
534 return _serde::__private::Err(__err);
535 }
536 },
537 );
538 }
539 4usize => {
540 if _serde::__private::Option::is_some(&m_handleIn) {
541 return _serde::__private::Err(
542 <__A::Error as _serde::de::Error>::duplicate_field(
543 "handleIn",
544 ),
545 );
546 }
547 m_handleIn = _serde::__private::Some(
548 match __A::next_value::<Pointer>(&mut __map) {
549 _serde::__private::Ok(__val) => __val,
550 _serde::__private::Err(__err) => {
551 return _serde::__private::Err(__err);
552 }
553 },
554 );
555 }
556 5usize => {
557 if _serde::__private::Option::is_some(&m_localFrameName) {
558 return _serde::__private::Err(
559 <__A::Error as _serde::de::Error>::duplicate_field(
560 "localFrameName",
561 ),
562 );
563 }
564 m_localFrameName = _serde::__private::Some(
565 match __A::next_value::<StringPtr<'de>>(&mut __map) {
566 _serde::__private::Ok(__val) => __val,
567 _serde::__private::Err(__err) => {
568 return _serde::__private::Err(__err);
569 }
570 },
571 );
572 }
573 6usize => {
574 if _serde::__private::Option::is_some(
575 &m_sensorLocalFrameName,
576 ) {
577 return _serde::__private::Err(
578 <__A::Error as _serde::de::Error>::duplicate_field(
579 "sensorLocalFrameName",
580 ),
581 );
582 }
583 m_sensorLocalFrameName = _serde::__private::Some(
584 match __A::next_value::<StringPtr<'de>>(&mut __map) {
585 _serde::__private::Ok(__val) => __val,
586 _serde::__private::Err(__err) => {
587 return _serde::__private::Err(__err);
588 }
589 },
590 );
591 }
592 7usize => {
593 if _serde::__private::Option::is_some(&m_minDistance) {
594 return _serde::__private::Err(
595 <__A::Error as _serde::de::Error>::duplicate_field(
596 "minDistance",
597 ),
598 );
599 }
600 m_minDistance = _serde::__private::Some(
601 match __A::next_value::<f32>(&mut __map) {
602 _serde::__private::Ok(__val) => __val,
603 _serde::__private::Err(__err) => {
604 return _serde::__private::Err(__err);
605 }
606 },
607 );
608 }
609 8usize => {
610 if _serde::__private::Option::is_some(&m_maxDistance) {
611 return _serde::__private::Err(
612 <__A::Error as _serde::de::Error>::duplicate_field(
613 "maxDistance",
614 ),
615 );
616 }
617 m_maxDistance = _serde::__private::Some(
618 match __A::next_value::<f32>(&mut __map) {
619 _serde::__private::Ok(__val) => __val,
620 _serde::__private::Err(__err) => {
621 return _serde::__private::Err(__err);
622 }
623 },
624 );
625 }
626 9usize => {
627 if _serde::__private::Option::is_some(&m_distanceOut) {
628 return _serde::__private::Err(
629 <__A::Error as _serde::de::Error>::duplicate_field(
630 "distanceOut",
631 ),
632 );
633 }
634 m_distanceOut = _serde::__private::Some(
635 match __A::next_value::<f32>(&mut __map) {
636 _serde::__private::Ok(__val) => __val,
637 _serde::__private::Err(__err) => {
638 return _serde::__private::Err(__err);
639 }
640 },
641 );
642 }
643 10usize => {
644 if _serde::__private::Option::is_some(
645 &m_collisionFilterInfo,
646 ) {
647 return _serde::__private::Err(
648 <__A::Error as _serde::de::Error>::duplicate_field(
649 "collisionFilterInfo",
650 ),
651 );
652 }
653 m_collisionFilterInfo = _serde::__private::Some(
654 match __A::next_value::<u32>(&mut __map) {
655 _serde::__private::Ok(__val) => __val,
656 _serde::__private::Err(__err) => {
657 return _serde::__private::Err(__err);
658 }
659 },
660 );
661 }
662 11usize => {
663 if _serde::__private::Option::is_some(
664 &m_sensorRagdollBoneIndex,
665 ) {
666 return _serde::__private::Err(
667 <__A::Error as _serde::de::Error>::duplicate_field(
668 "sensorRagdollBoneIndex",
669 ),
670 );
671 }
672 m_sensorRagdollBoneIndex = _serde::__private::Some(
673 match __A::next_value::<i16>(&mut __map) {
674 _serde::__private::Ok(__val) => __val,
675 _serde::__private::Err(__err) => {
676 return _serde::__private::Err(__err);
677 }
678 },
679 );
680 }
681 12usize => {
682 if _serde::__private::Option::is_some(
683 &m_sensorAnimationBoneIndex,
684 ) {
685 return _serde::__private::Err(
686 <__A::Error as _serde::de::Error>::duplicate_field(
687 "sensorAnimationBoneIndex",
688 ),
689 );
690 }
691 m_sensorAnimationBoneIndex = _serde::__private::Some(
692 match __A::next_value::<i16>(&mut __map) {
693 _serde::__private::Ok(__val) => __val,
694 _serde::__private::Err(__err) => {
695 return _serde::__private::Err(__err);
696 }
697 },
698 );
699 }
700 13usize => {
701 if _serde::__private::Option::is_some(&m_sensingMode) {
702 return _serde::__private::Err(
703 <__A::Error as _serde::de::Error>::duplicate_field(
704 "sensingMode",
705 ),
706 );
707 }
708 m_sensingMode = _serde::__private::Some(
709 match __A::next_value::<SensingMode>(&mut __map) {
710 _serde::__private::Ok(__val) => __val,
711 _serde::__private::Err(__err) => {
712 return _serde::__private::Err(__err);
713 }
714 },
715 );
716 }
717 14usize => {
718 if _serde::__private::Option::is_some(
719 &m_extrapolateSensorPosition,
720 ) {
721 return _serde::__private::Err(
722 <__A::Error as _serde::de::Error>::duplicate_field(
723 "extrapolateSensorPosition",
724 ),
725 );
726 }
727 m_extrapolateSensorPosition = _serde::__private::Some(
728 match __A::next_value::<bool>(&mut __map) {
729 _serde::__private::Ok(__val) => __val,
730 _serde::__private::Err(__err) => {
731 return _serde::__private::Err(__err);
732 }
733 },
734 );
735 }
736 15usize => {
737 if _serde::__private::Option::is_some(
738 &m_keepFirstSensedHandle,
739 ) {
740 return _serde::__private::Err(
741 <__A::Error as _serde::de::Error>::duplicate_field(
742 "keepFirstSensedHandle",
743 ),
744 );
745 }
746 m_keepFirstSensedHandle = _serde::__private::Some(
747 match __A::next_value::<bool>(&mut __map) {
748 _serde::__private::Ok(__val) => __val,
749 _serde::__private::Err(__err) => {
750 return _serde::__private::Err(__err);
751 }
752 },
753 );
754 }
755 16usize => {
756 if _serde::__private::Option::is_some(&m_foundHandleOut) {
757 return _serde::__private::Err(
758 <__A::Error as _serde::de::Error>::duplicate_field(
759 "foundHandleOut",
760 ),
761 );
762 }
763 m_foundHandleOut = _serde::__private::Some(
764 match __A::next_value::<bool>(&mut __map) {
765 _serde::__private::Ok(__val) => __val,
766 _serde::__private::Err(__err) => {
767 return _serde::__private::Err(__err);
768 }
769 },
770 );
771 }
772 17usize => {
773 if _serde::__private::Option::is_some(
774 &m_timeSinceLastModify,
775 ) {
776 return _serde::__private::Err(
777 <__A::Error as _serde::de::Error>::duplicate_field(
778 "timeSinceLastModify",
779 ),
780 );
781 }
782 m_timeSinceLastModify = _serde::__private::Some(
783 match __A::next_value::<f32>(&mut __map) {
784 _serde::__private::Ok(__val) => __val,
785 _serde::__private::Err(__err) => {
786 return _serde::__private::Err(__err);
787 }
788 },
789 );
790 }
791 18usize => {
792 if _serde::__private::Option::is_some(
793 &m_rangeIndexForEventToSendNextUpdate,
794 ) {
795 return _serde::__private::Err(
796 <__A::Error as _serde::de::Error>::duplicate_field(
797 "rangeIndexForEventToSendNextUpdate",
798 ),
799 );
800 }
801 m_rangeIndexForEventToSendNextUpdate = _serde::__private::Some(
802 match __A::next_value::<i32>(&mut __map) {
803 _serde::__private::Ok(__val) => __val,
804 _serde::__private::Err(__err) => {
805 return _serde::__private::Err(__err);
806 }
807 },
808 );
809 }
810 _ => {}
811 }
812 }
813 __A::pad(&mut __map, 4usize, 0usize)?;
814 let m_handle = match m_handle {
815 _serde::__private::Some(__field) => __field,
816 _serde::__private::None => {
817 return _serde::__private::Err(
818 <__A::Error as _serde::de::Error>::missing_field("handle"),
819 );
820 }
821 };
822 let m_sensorLocalOffset = match m_sensorLocalOffset {
823 _serde::__private::Some(__field) => __field,
824 _serde::__private::None => {
825 return _serde::__private::Err(
826 <__A::Error as _serde::de::Error>::missing_field(
827 "sensorLocalOffset",
828 ),
829 );
830 }
831 };
832 let m_ranges = match m_ranges {
833 _serde::__private::Some(__field) => __field,
834 _serde::__private::None => {
835 return _serde::__private::Err(
836 <__A::Error as _serde::de::Error>::missing_field("ranges"),
837 );
838 }
839 };
840 let m_handleOut = match m_handleOut {
841 _serde::__private::Some(__field) => __field,
842 _serde::__private::None => {
843 return _serde::__private::Err(
844 <__A::Error as _serde::de::Error>::missing_field(
845 "handleOut",
846 ),
847 );
848 }
849 };
850 let m_handleIn = match m_handleIn {
851 _serde::__private::Some(__field) => __field,
852 _serde::__private::None => {
853 return _serde::__private::Err(
854 <__A::Error as _serde::de::Error>::missing_field("handleIn"),
855 );
856 }
857 };
858 let m_localFrameName = match m_localFrameName {
859 _serde::__private::Some(__field) => __field,
860 _serde::__private::None => {
861 return _serde::__private::Err(
862 <__A::Error as _serde::de::Error>::missing_field(
863 "localFrameName",
864 ),
865 );
866 }
867 };
868 let m_sensorLocalFrameName = match m_sensorLocalFrameName {
869 _serde::__private::Some(__field) => __field,
870 _serde::__private::None => {
871 return _serde::__private::Err(
872 <__A::Error as _serde::de::Error>::missing_field(
873 "sensorLocalFrameName",
874 ),
875 );
876 }
877 };
878 let m_minDistance = match m_minDistance {
879 _serde::__private::Some(__field) => __field,
880 _serde::__private::None => {
881 return _serde::__private::Err(
882 <__A::Error as _serde::de::Error>::missing_field(
883 "minDistance",
884 ),
885 );
886 }
887 };
888 let m_maxDistance = match m_maxDistance {
889 _serde::__private::Some(__field) => __field,
890 _serde::__private::None => {
891 return _serde::__private::Err(
892 <__A::Error as _serde::de::Error>::missing_field(
893 "maxDistance",
894 ),
895 );
896 }
897 };
898 let m_distanceOut = match m_distanceOut {
899 _serde::__private::Some(__field) => __field,
900 _serde::__private::None => {
901 return _serde::__private::Err(
902 <__A::Error as _serde::de::Error>::missing_field(
903 "distanceOut",
904 ),
905 );
906 }
907 };
908 let m_collisionFilterInfo = match m_collisionFilterInfo {
909 _serde::__private::Some(__field) => __field,
910 _serde::__private::None => {
911 return _serde::__private::Err(
912 <__A::Error as _serde::de::Error>::missing_field(
913 "collisionFilterInfo",
914 ),
915 );
916 }
917 };
918 let m_sensorRagdollBoneIndex = match m_sensorRagdollBoneIndex {
919 _serde::__private::Some(__field) => __field,
920 _serde::__private::None => {
921 return _serde::__private::Err(
922 <__A::Error as _serde::de::Error>::missing_field(
923 "sensorRagdollBoneIndex",
924 ),
925 );
926 }
927 };
928 let m_sensorAnimationBoneIndex = match m_sensorAnimationBoneIndex {
929 _serde::__private::Some(__field) => __field,
930 _serde::__private::None => {
931 return _serde::__private::Err(
932 <__A::Error as _serde::de::Error>::missing_field(
933 "sensorAnimationBoneIndex",
934 ),
935 );
936 }
937 };
938 let m_sensingMode = match m_sensingMode {
939 _serde::__private::Some(__field) => __field,
940 _serde::__private::None => {
941 return _serde::__private::Err(
942 <__A::Error as _serde::de::Error>::missing_field(
943 "sensingMode",
944 ),
945 );
946 }
947 };
948 let m_extrapolateSensorPosition = match m_extrapolateSensorPosition {
949 _serde::__private::Some(__field) => __field,
950 _serde::__private::None => {
951 return _serde::__private::Err(
952 <__A::Error as _serde::de::Error>::missing_field(
953 "extrapolateSensorPosition",
954 ),
955 );
956 }
957 };
958 let m_keepFirstSensedHandle = match m_keepFirstSensedHandle {
959 _serde::__private::Some(__field) => __field,
960 _serde::__private::None => {
961 return _serde::__private::Err(
962 <__A::Error as _serde::de::Error>::missing_field(
963 "keepFirstSensedHandle",
964 ),
965 );
966 }
967 };
968 let m_foundHandleOut = match m_foundHandleOut {
969 _serde::__private::Some(__field) => __field,
970 _serde::__private::None => {
971 return _serde::__private::Err(
972 <__A::Error as _serde::de::Error>::missing_field(
973 "foundHandleOut",
974 ),
975 );
976 }
977 };
978 let m_timeSinceLastModify = match m_timeSinceLastModify {
979 _serde::__private::Some(__field) => __field,
980 _serde::__private::None => {
981 return _serde::__private::Err(
982 <__A::Error as _serde::de::Error>::missing_field(
983 "timeSinceLastModify",
984 ),
985 );
986 }
987 };
988 let m_rangeIndexForEventToSendNextUpdate = match m_rangeIndexForEventToSendNextUpdate {
989 _serde::__private::Some(__field) => __field,
990 _serde::__private::None => {
991 return _serde::__private::Err(
992 <__A::Error as _serde::de::Error>::missing_field(
993 "rangeIndexForEventToSendNextUpdate",
994 ),
995 );
996 }
997 };
998 _serde::__private::Ok(hkbSenseHandleModifier {
999 __ptr,
1000 parent,
1001 m_handle,
1002 m_sensorLocalOffset,
1003 m_ranges,
1004 m_handleOut,
1005 m_handleIn,
1006 m_localFrameName,
1007 m_sensorLocalFrameName,
1008 m_minDistance,
1009 m_maxDistance,
1010 m_distanceOut,
1011 m_collisionFilterInfo,
1012 m_sensorRagdollBoneIndex,
1013 m_sensorAnimationBoneIndex,
1014 m_sensingMode,
1015 m_extrapolateSensorPosition,
1016 m_keepFirstSensedHandle,
1017 m_foundHandleOut,
1018 m_timeSinceLastModify,
1019 m_rangeIndexForEventToSendNextUpdate,
1020 })
1021 }
1022 #[allow(clippy::manual_unwrap_or_default)]
1023 fn visit_struct<__A>(
1024 self,
1025 mut __map: __A,
1026 ) -> _serde::__private::Result<Self::Value, __A::Error>
1027 where
1028 __A: _serde::de::MapAccess<'de>,
1029 {
1030 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
1031 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1032 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1033 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
1034 let mut m_sensorLocalOffset: _serde::__private::Option<Vector4> = _serde::__private::None;
1035 let mut m_ranges: _serde::__private::Option<
1036 Vec<hkbSenseHandleModifierRange>,
1037 > = _serde::__private::None;
1038 let mut m_handleOut: _serde::__private::Option<Pointer> = _serde::__private::None;
1039 let mut m_handleIn: _serde::__private::Option<Pointer> = _serde::__private::None;
1040 let mut m_localFrameName: _serde::__private::Option<
1041 StringPtr<'de>,
1042 > = _serde::__private::None;
1043 let mut m_sensorLocalFrameName: _serde::__private::Option<
1044 StringPtr<'de>,
1045 > = _serde::__private::None;
1046 let mut m_minDistance: _serde::__private::Option<f32> = _serde::__private::None;
1047 let mut m_maxDistance: _serde::__private::Option<f32> = _serde::__private::None;
1048 let mut m_distanceOut: _serde::__private::Option<f32> = _serde::__private::None;
1049 let mut m_collisionFilterInfo: _serde::__private::Option<u32> = _serde::__private::None;
1050 let mut m_sensorRagdollBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
1051 let mut m_sensorAnimationBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
1052 let mut m_sensingMode: _serde::__private::Option<SensingMode> = _serde::__private::None;
1053 let mut m_extrapolateSensorPosition: _serde::__private::Option<
1054 bool,
1055 > = _serde::__private::None;
1056 let mut m_keepFirstSensedHandle: _serde::__private::Option<bool> = _serde::__private::None;
1057 let mut m_foundHandleOut: _serde::__private::Option<bool> = _serde::__private::None;
1058 while let _serde::__private::Some(__key) = {
1059 __A::next_key::<__Field>(&mut __map)?
1060 } {
1061 match __key {
1062 __Field::m_variableBindingSet => {
1063 #[cfg(
1064 any(feature = "strict", feature = "ignore_duplicates")
1065 )]
1066 if _serde::__private::Option::is_some(
1067 &m_variableBindingSet,
1068 ) {
1069 #[cfg(feature = "ignore_duplicates")]
1070 {
1071 __A::skip_value(&mut __map)?;
1072 continue;
1073 }
1074 #[cfg(feature = "strict")]
1075 return _serde::__private::Err(
1076 <__A::Error as _serde::de::Error>::duplicate_field(
1077 "variableBindingSet",
1078 ),
1079 );
1080 }
1081 m_variableBindingSet = _serde::__private::Some(
1082 match __A::next_value::<Pointer>(&mut __map) {
1083 _serde::__private::Ok(__val) => __val,
1084 _serde::__private::Err(__err) => {
1085 return _serde::__private::Err(__err);
1086 }
1087 },
1088 );
1089 }
1090 __Field::m_userData => {
1091 #[cfg(
1092 any(feature = "strict", feature = "ignore_duplicates")
1093 )]
1094 if _serde::__private::Option::is_some(&m_userData) {
1095 #[cfg(feature = "ignore_duplicates")]
1096 {
1097 __A::skip_value(&mut __map)?;
1098 continue;
1099 }
1100 #[cfg(feature = "strict")]
1101 return _serde::__private::Err(
1102 <__A::Error as _serde::de::Error>::duplicate_field(
1103 "userData",
1104 ),
1105 );
1106 }
1107 m_userData = _serde::__private::Some(
1108 match __A::next_value::<Ulong>(&mut __map) {
1109 _serde::__private::Ok(__val) => __val,
1110 _serde::__private::Err(__err) => {
1111 return _serde::__private::Err(__err);
1112 }
1113 },
1114 );
1115 }
1116 __Field::m_name => {
1117 #[cfg(
1118 any(feature = "strict", feature = "ignore_duplicates")
1119 )]
1120 if _serde::__private::Option::is_some(&m_name) {
1121 #[cfg(feature = "ignore_duplicates")]
1122 {
1123 __A::skip_value(&mut __map)?;
1124 continue;
1125 }
1126 #[cfg(feature = "strict")]
1127 return _serde::__private::Err(
1128 <__A::Error as _serde::de::Error>::duplicate_field("name"),
1129 );
1130 }
1131 m_name = _serde::__private::Some(
1132 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1133 _serde::__private::Ok(__val) => __val,
1134 _serde::__private::Err(__err) => {
1135 return _serde::__private::Err(__err);
1136 }
1137 },
1138 );
1139 }
1140 __Field::m_enable => {
1141 #[cfg(
1142 any(feature = "strict", feature = "ignore_duplicates")
1143 )]
1144 if _serde::__private::Option::is_some(&m_enable) {
1145 #[cfg(feature = "ignore_duplicates")]
1146 {
1147 __A::skip_value(&mut __map)?;
1148 continue;
1149 }
1150 #[cfg(feature = "strict")]
1151 return _serde::__private::Err(
1152 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
1153 );
1154 }
1155 m_enable = _serde::__private::Some(
1156 match __A::next_value::<bool>(&mut __map) {
1157 _serde::__private::Ok(__val) => __val,
1158 _serde::__private::Err(__err) => {
1159 return _serde::__private::Err(__err);
1160 }
1161 },
1162 );
1163 }
1164 __Field::m_sensorLocalOffset => {
1165 #[cfg(
1166 any(feature = "strict", feature = "ignore_duplicates")
1167 )]
1168 if _serde::__private::Option::is_some(
1169 &m_sensorLocalOffset,
1170 ) {
1171 #[cfg(feature = "ignore_duplicates")]
1172 {
1173 __A::skip_value(&mut __map)?;
1174 continue;
1175 }
1176 #[cfg(feature = "strict")]
1177 return _serde::__private::Err(
1178 <__A::Error as _serde::de::Error>::duplicate_field(
1179 "sensorLocalOffset",
1180 ),
1181 );
1182 }
1183 m_sensorLocalOffset = _serde::__private::Some(
1184 match __A::next_value::<Vector4>(&mut __map) {
1185 _serde::__private::Ok(__val) => __val,
1186 _serde::__private::Err(__err) => {
1187 return _serde::__private::Err(__err);
1188 }
1189 },
1190 );
1191 }
1192 __Field::m_ranges => {
1193 #[cfg(
1194 any(feature = "strict", feature = "ignore_duplicates")
1195 )]
1196 if _serde::__private::Option::is_some(&m_ranges) {
1197 #[cfg(feature = "ignore_duplicates")]
1198 {
1199 __A::skip_value(&mut __map)?;
1200 continue;
1201 }
1202 #[cfg(feature = "strict")]
1203 return _serde::__private::Err(
1204 <__A::Error as _serde::de::Error>::duplicate_field("ranges"),
1205 );
1206 }
1207 m_ranges = _serde::__private::Some(
1208 match __A::next_value::<
1209 Vec<hkbSenseHandleModifierRange>,
1210 >(&mut __map) {
1211 _serde::__private::Ok(__val) => __val,
1212 _serde::__private::Err(__err) => {
1213 return _serde::__private::Err(__err);
1214 }
1215 },
1216 );
1217 }
1218 __Field::m_handleOut => {
1219 #[cfg(
1220 any(feature = "strict", feature = "ignore_duplicates")
1221 )]
1222 if _serde::__private::Option::is_some(&m_handleOut) {
1223 #[cfg(feature = "ignore_duplicates")]
1224 {
1225 __A::skip_value(&mut __map)?;
1226 continue;
1227 }
1228 #[cfg(feature = "strict")]
1229 return _serde::__private::Err(
1230 <__A::Error as _serde::de::Error>::duplicate_field(
1231 "handleOut",
1232 ),
1233 );
1234 }
1235 m_handleOut = _serde::__private::Some(
1236 match __A::next_value::<Pointer>(&mut __map) {
1237 _serde::__private::Ok(__val) => __val,
1238 _serde::__private::Err(__err) => {
1239 return _serde::__private::Err(__err);
1240 }
1241 },
1242 );
1243 }
1244 __Field::m_handleIn => {
1245 #[cfg(
1246 any(feature = "strict", feature = "ignore_duplicates")
1247 )]
1248 if _serde::__private::Option::is_some(&m_handleIn) {
1249 #[cfg(feature = "ignore_duplicates")]
1250 {
1251 __A::skip_value(&mut __map)?;
1252 continue;
1253 }
1254 #[cfg(feature = "strict")]
1255 return _serde::__private::Err(
1256 <__A::Error as _serde::de::Error>::duplicate_field(
1257 "handleIn",
1258 ),
1259 );
1260 }
1261 m_handleIn = _serde::__private::Some(
1262 match __A::next_value::<Pointer>(&mut __map) {
1263 _serde::__private::Ok(__val) => __val,
1264 _serde::__private::Err(__err) => {
1265 return _serde::__private::Err(__err);
1266 }
1267 },
1268 );
1269 }
1270 __Field::m_localFrameName => {
1271 #[cfg(
1272 any(feature = "strict", feature = "ignore_duplicates")
1273 )]
1274 if _serde::__private::Option::is_some(&m_localFrameName) {
1275 #[cfg(feature = "ignore_duplicates")]
1276 {
1277 __A::skip_value(&mut __map)?;
1278 continue;
1279 }
1280 #[cfg(feature = "strict")]
1281 return _serde::__private::Err(
1282 <__A::Error as _serde::de::Error>::duplicate_field(
1283 "localFrameName",
1284 ),
1285 );
1286 }
1287 m_localFrameName = _serde::__private::Some(
1288 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1289 _serde::__private::Ok(__val) => __val,
1290 _serde::__private::Err(__err) => {
1291 return _serde::__private::Err(__err);
1292 }
1293 },
1294 );
1295 }
1296 __Field::m_sensorLocalFrameName => {
1297 #[cfg(
1298 any(feature = "strict", feature = "ignore_duplicates")
1299 )]
1300 if _serde::__private::Option::is_some(
1301 &m_sensorLocalFrameName,
1302 ) {
1303 #[cfg(feature = "ignore_duplicates")]
1304 {
1305 __A::skip_value(&mut __map)?;
1306 continue;
1307 }
1308 #[cfg(feature = "strict")]
1309 return _serde::__private::Err(
1310 <__A::Error as _serde::de::Error>::duplicate_field(
1311 "sensorLocalFrameName",
1312 ),
1313 );
1314 }
1315 m_sensorLocalFrameName = _serde::__private::Some(
1316 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1317 _serde::__private::Ok(__val) => __val,
1318 _serde::__private::Err(__err) => {
1319 return _serde::__private::Err(__err);
1320 }
1321 },
1322 );
1323 }
1324 __Field::m_minDistance => {
1325 #[cfg(
1326 any(feature = "strict", feature = "ignore_duplicates")
1327 )]
1328 if _serde::__private::Option::is_some(&m_minDistance) {
1329 #[cfg(feature = "ignore_duplicates")]
1330 {
1331 __A::skip_value(&mut __map)?;
1332 continue;
1333 }
1334 #[cfg(feature = "strict")]
1335 return _serde::__private::Err(
1336 <__A::Error as _serde::de::Error>::duplicate_field(
1337 "minDistance",
1338 ),
1339 );
1340 }
1341 m_minDistance = _serde::__private::Some(
1342 match __A::next_value::<f32>(&mut __map) {
1343 _serde::__private::Ok(__val) => __val,
1344 _serde::__private::Err(__err) => {
1345 return _serde::__private::Err(__err);
1346 }
1347 },
1348 );
1349 }
1350 __Field::m_maxDistance => {
1351 #[cfg(
1352 any(feature = "strict", feature = "ignore_duplicates")
1353 )]
1354 if _serde::__private::Option::is_some(&m_maxDistance) {
1355 #[cfg(feature = "ignore_duplicates")]
1356 {
1357 __A::skip_value(&mut __map)?;
1358 continue;
1359 }
1360 #[cfg(feature = "strict")]
1361 return _serde::__private::Err(
1362 <__A::Error as _serde::de::Error>::duplicate_field(
1363 "maxDistance",
1364 ),
1365 );
1366 }
1367 m_maxDistance = _serde::__private::Some(
1368 match __A::next_value::<f32>(&mut __map) {
1369 _serde::__private::Ok(__val) => __val,
1370 _serde::__private::Err(__err) => {
1371 return _serde::__private::Err(__err);
1372 }
1373 },
1374 );
1375 }
1376 __Field::m_distanceOut => {
1377 #[cfg(
1378 any(feature = "strict", feature = "ignore_duplicates")
1379 )]
1380 if _serde::__private::Option::is_some(&m_distanceOut) {
1381 #[cfg(feature = "ignore_duplicates")]
1382 {
1383 __A::skip_value(&mut __map)?;
1384 continue;
1385 }
1386 #[cfg(feature = "strict")]
1387 return _serde::__private::Err(
1388 <__A::Error as _serde::de::Error>::duplicate_field(
1389 "distanceOut",
1390 ),
1391 );
1392 }
1393 m_distanceOut = _serde::__private::Some(
1394 match __A::next_value::<f32>(&mut __map) {
1395 _serde::__private::Ok(__val) => __val,
1396 _serde::__private::Err(__err) => {
1397 return _serde::__private::Err(__err);
1398 }
1399 },
1400 );
1401 }
1402 __Field::m_collisionFilterInfo => {
1403 #[cfg(
1404 any(feature = "strict", feature = "ignore_duplicates")
1405 )]
1406 if _serde::__private::Option::is_some(
1407 &m_collisionFilterInfo,
1408 ) {
1409 #[cfg(feature = "ignore_duplicates")]
1410 {
1411 __A::skip_value(&mut __map)?;
1412 continue;
1413 }
1414 #[cfg(feature = "strict")]
1415 return _serde::__private::Err(
1416 <__A::Error as _serde::de::Error>::duplicate_field(
1417 "collisionFilterInfo",
1418 ),
1419 );
1420 }
1421 m_collisionFilterInfo = _serde::__private::Some(
1422 match __A::next_value::<u32>(&mut __map) {
1423 _serde::__private::Ok(__val) => __val,
1424 _serde::__private::Err(__err) => {
1425 return _serde::__private::Err(__err);
1426 }
1427 },
1428 );
1429 }
1430 __Field::m_sensorRagdollBoneIndex => {
1431 #[cfg(
1432 any(feature = "strict", feature = "ignore_duplicates")
1433 )]
1434 if _serde::__private::Option::is_some(
1435 &m_sensorRagdollBoneIndex,
1436 ) {
1437 #[cfg(feature = "ignore_duplicates")]
1438 {
1439 __A::skip_value(&mut __map)?;
1440 continue;
1441 }
1442 #[cfg(feature = "strict")]
1443 return _serde::__private::Err(
1444 <__A::Error as _serde::de::Error>::duplicate_field(
1445 "sensorRagdollBoneIndex",
1446 ),
1447 );
1448 }
1449 m_sensorRagdollBoneIndex = _serde::__private::Some(
1450 match __A::next_value::<i16>(&mut __map) {
1451 _serde::__private::Ok(__val) => __val,
1452 _serde::__private::Err(__err) => {
1453 return _serde::__private::Err(__err);
1454 }
1455 },
1456 );
1457 }
1458 __Field::m_sensorAnimationBoneIndex => {
1459 #[cfg(
1460 any(feature = "strict", feature = "ignore_duplicates")
1461 )]
1462 if _serde::__private::Option::is_some(
1463 &m_sensorAnimationBoneIndex,
1464 ) {
1465 #[cfg(feature = "ignore_duplicates")]
1466 {
1467 __A::skip_value(&mut __map)?;
1468 continue;
1469 }
1470 #[cfg(feature = "strict")]
1471 return _serde::__private::Err(
1472 <__A::Error as _serde::de::Error>::duplicate_field(
1473 "sensorAnimationBoneIndex",
1474 ),
1475 );
1476 }
1477 m_sensorAnimationBoneIndex = _serde::__private::Some(
1478 match __A::next_value::<i16>(&mut __map) {
1479 _serde::__private::Ok(__val) => __val,
1480 _serde::__private::Err(__err) => {
1481 return _serde::__private::Err(__err);
1482 }
1483 },
1484 );
1485 }
1486 __Field::m_sensingMode => {
1487 #[cfg(
1488 any(feature = "strict", feature = "ignore_duplicates")
1489 )]
1490 if _serde::__private::Option::is_some(&m_sensingMode) {
1491 #[cfg(feature = "ignore_duplicates")]
1492 {
1493 __A::skip_value(&mut __map)?;
1494 continue;
1495 }
1496 #[cfg(feature = "strict")]
1497 return _serde::__private::Err(
1498 <__A::Error as _serde::de::Error>::duplicate_field(
1499 "sensingMode",
1500 ),
1501 );
1502 }
1503 m_sensingMode = _serde::__private::Some(
1504 match __A::next_value::<SensingMode>(&mut __map) {
1505 _serde::__private::Ok(__val) => __val,
1506 _serde::__private::Err(__err) => {
1507 return _serde::__private::Err(__err);
1508 }
1509 },
1510 );
1511 }
1512 __Field::m_extrapolateSensorPosition => {
1513 #[cfg(
1514 any(feature = "strict", feature = "ignore_duplicates")
1515 )]
1516 if _serde::__private::Option::is_some(
1517 &m_extrapolateSensorPosition,
1518 ) {
1519 #[cfg(feature = "ignore_duplicates")]
1520 {
1521 __A::skip_value(&mut __map)?;
1522 continue;
1523 }
1524 #[cfg(feature = "strict")]
1525 return _serde::__private::Err(
1526 <__A::Error as _serde::de::Error>::duplicate_field(
1527 "extrapolateSensorPosition",
1528 ),
1529 );
1530 }
1531 m_extrapolateSensorPosition = _serde::__private::Some(
1532 match __A::next_value::<bool>(&mut __map) {
1533 _serde::__private::Ok(__val) => __val,
1534 _serde::__private::Err(__err) => {
1535 return _serde::__private::Err(__err);
1536 }
1537 },
1538 );
1539 }
1540 __Field::m_keepFirstSensedHandle => {
1541 #[cfg(
1542 any(feature = "strict", feature = "ignore_duplicates")
1543 )]
1544 if _serde::__private::Option::is_some(
1545 &m_keepFirstSensedHandle,
1546 ) {
1547 #[cfg(feature = "ignore_duplicates")]
1548 {
1549 __A::skip_value(&mut __map)?;
1550 continue;
1551 }
1552 #[cfg(feature = "strict")]
1553 return _serde::__private::Err(
1554 <__A::Error as _serde::de::Error>::duplicate_field(
1555 "keepFirstSensedHandle",
1556 ),
1557 );
1558 }
1559 m_keepFirstSensedHandle = _serde::__private::Some(
1560 match __A::next_value::<bool>(&mut __map) {
1561 _serde::__private::Ok(__val) => __val,
1562 _serde::__private::Err(__err) => {
1563 return _serde::__private::Err(__err);
1564 }
1565 },
1566 );
1567 }
1568 __Field::m_foundHandleOut => {
1569 #[cfg(
1570 any(feature = "strict", feature = "ignore_duplicates")
1571 )]
1572 if _serde::__private::Option::is_some(&m_foundHandleOut) {
1573 #[cfg(feature = "ignore_duplicates")]
1574 {
1575 __A::skip_value(&mut __map)?;
1576 continue;
1577 }
1578 #[cfg(feature = "strict")]
1579 return _serde::__private::Err(
1580 <__A::Error as _serde::de::Error>::duplicate_field(
1581 "foundHandleOut",
1582 ),
1583 );
1584 }
1585 m_foundHandleOut = _serde::__private::Some(
1586 match __A::next_value::<bool>(&mut __map) {
1587 _serde::__private::Ok(__val) => __val,
1588 _serde::__private::Err(__err) => {
1589 return _serde::__private::Err(__err);
1590 }
1591 },
1592 );
1593 }
1594 _ => __A::skip_value(&mut __map)?,
1595 }
1596 }
1597 let m_variableBindingSet = match m_variableBindingSet {
1598 _serde::__private::Some(__field) => __field,
1599 _serde::__private::None => {
1600 #[cfg(feature = "strict")]
1601 return _serde::__private::Err(
1602 <__A::Error as _serde::de::Error>::missing_field(
1603 "variableBindingSet",
1604 ),
1605 );
1606 #[cfg(not(feature = "strict"))] Default::default()
1607 }
1608 };
1609 let m_userData = match m_userData {
1610 _serde::__private::Some(__field) => __field,
1611 _serde::__private::None => {
1612 #[cfg(feature = "strict")]
1613 return _serde::__private::Err(
1614 <__A::Error as _serde::de::Error>::missing_field("userData"),
1615 );
1616 #[cfg(not(feature = "strict"))] Default::default()
1617 }
1618 };
1619 let m_name = match m_name {
1620 _serde::__private::Some(__field) => __field,
1621 _serde::__private::None => {
1622 #[cfg(feature = "strict")]
1623 return _serde::__private::Err(
1624 <__A::Error as _serde::de::Error>::missing_field("name"),
1625 );
1626 #[cfg(not(feature = "strict"))] Default::default()
1627 }
1628 };
1629 let m_enable = match m_enable {
1630 _serde::__private::Some(__field) => __field,
1631 _serde::__private::None => {
1632 #[cfg(feature = "strict")]
1633 return _serde::__private::Err(
1634 <__A::Error as _serde::de::Error>::missing_field("enable"),
1635 );
1636 #[cfg(not(feature = "strict"))] Default::default()
1637 }
1638 };
1639 let m_sensorLocalOffset = match m_sensorLocalOffset {
1640 _serde::__private::Some(__field) => __field,
1641 _serde::__private::None => {
1642 #[cfg(feature = "strict")]
1643 return _serde::__private::Err(
1644 <__A::Error as _serde::de::Error>::missing_field(
1645 "sensorLocalOffset",
1646 ),
1647 );
1648 #[cfg(not(feature = "strict"))] Default::default()
1649 }
1650 };
1651 let m_ranges = match m_ranges {
1652 _serde::__private::Some(__field) => __field,
1653 _serde::__private::None => {
1654 #[cfg(feature = "strict")]
1655 return _serde::__private::Err(
1656 <__A::Error as _serde::de::Error>::missing_field("ranges"),
1657 );
1658 #[cfg(not(feature = "strict"))] Default::default()
1659 }
1660 };
1661 let m_handleOut = match m_handleOut {
1662 _serde::__private::Some(__field) => __field,
1663 _serde::__private::None => {
1664 #[cfg(feature = "strict")]
1665 return _serde::__private::Err(
1666 <__A::Error as _serde::de::Error>::missing_field(
1667 "handleOut",
1668 ),
1669 );
1670 #[cfg(not(feature = "strict"))] Default::default()
1671 }
1672 };
1673 let m_handleIn = match m_handleIn {
1674 _serde::__private::Some(__field) => __field,
1675 _serde::__private::None => {
1676 #[cfg(feature = "strict")]
1677 return _serde::__private::Err(
1678 <__A::Error as _serde::de::Error>::missing_field("handleIn"),
1679 );
1680 #[cfg(not(feature = "strict"))] Default::default()
1681 }
1682 };
1683 let m_localFrameName = match m_localFrameName {
1684 _serde::__private::Some(__field) => __field,
1685 _serde::__private::None => {
1686 #[cfg(feature = "strict")]
1687 return _serde::__private::Err(
1688 <__A::Error as _serde::de::Error>::missing_field(
1689 "localFrameName",
1690 ),
1691 );
1692 #[cfg(not(feature = "strict"))] Default::default()
1693 }
1694 };
1695 let m_sensorLocalFrameName = match m_sensorLocalFrameName {
1696 _serde::__private::Some(__field) => __field,
1697 _serde::__private::None => {
1698 #[cfg(feature = "strict")]
1699 return _serde::__private::Err(
1700 <__A::Error as _serde::de::Error>::missing_field(
1701 "sensorLocalFrameName",
1702 ),
1703 );
1704 #[cfg(not(feature = "strict"))] Default::default()
1705 }
1706 };
1707 let m_minDistance = match m_minDistance {
1708 _serde::__private::Some(__field) => __field,
1709 _serde::__private::None => {
1710 #[cfg(feature = "strict")]
1711 return _serde::__private::Err(
1712 <__A::Error as _serde::de::Error>::missing_field(
1713 "minDistance",
1714 ),
1715 );
1716 #[cfg(not(feature = "strict"))] Default::default()
1717 }
1718 };
1719 let m_maxDistance = match m_maxDistance {
1720 _serde::__private::Some(__field) => __field,
1721 _serde::__private::None => {
1722 #[cfg(feature = "strict")]
1723 return _serde::__private::Err(
1724 <__A::Error as _serde::de::Error>::missing_field(
1725 "maxDistance",
1726 ),
1727 );
1728 #[cfg(not(feature = "strict"))] Default::default()
1729 }
1730 };
1731 let m_distanceOut = match m_distanceOut {
1732 _serde::__private::Some(__field) => __field,
1733 _serde::__private::None => {
1734 #[cfg(feature = "strict")]
1735 return _serde::__private::Err(
1736 <__A::Error as _serde::de::Error>::missing_field(
1737 "distanceOut",
1738 ),
1739 );
1740 #[cfg(not(feature = "strict"))] Default::default()
1741 }
1742 };
1743 let m_collisionFilterInfo = match m_collisionFilterInfo {
1744 _serde::__private::Some(__field) => __field,
1745 _serde::__private::None => {
1746 #[cfg(feature = "strict")]
1747 return _serde::__private::Err(
1748 <__A::Error as _serde::de::Error>::missing_field(
1749 "collisionFilterInfo",
1750 ),
1751 );
1752 #[cfg(not(feature = "strict"))] Default::default()
1753 }
1754 };
1755 let m_sensorRagdollBoneIndex = match m_sensorRagdollBoneIndex {
1756 _serde::__private::Some(__field) => __field,
1757 _serde::__private::None => {
1758 #[cfg(feature = "strict")]
1759 return _serde::__private::Err(
1760 <__A::Error as _serde::de::Error>::missing_field(
1761 "sensorRagdollBoneIndex",
1762 ),
1763 );
1764 #[cfg(not(feature = "strict"))] Default::default()
1765 }
1766 };
1767 let m_sensorAnimationBoneIndex = match m_sensorAnimationBoneIndex {
1768 _serde::__private::Some(__field) => __field,
1769 _serde::__private::None => {
1770 #[cfg(feature = "strict")]
1771 return _serde::__private::Err(
1772 <__A::Error as _serde::de::Error>::missing_field(
1773 "sensorAnimationBoneIndex",
1774 ),
1775 );
1776 #[cfg(not(feature = "strict"))] Default::default()
1777 }
1778 };
1779 let m_sensingMode = match m_sensingMode {
1780 _serde::__private::Some(__field) => __field,
1781 _serde::__private::None => {
1782 #[cfg(feature = "strict")]
1783 return _serde::__private::Err(
1784 <__A::Error as _serde::de::Error>::missing_field(
1785 "sensingMode",
1786 ),
1787 );
1788 #[cfg(not(feature = "strict"))] Default::default()
1789 }
1790 };
1791 let m_extrapolateSensorPosition = match m_extrapolateSensorPosition {
1792 _serde::__private::Some(__field) => __field,
1793 _serde::__private::None => {
1794 #[cfg(feature = "strict")]
1795 return _serde::__private::Err(
1796 <__A::Error as _serde::de::Error>::missing_field(
1797 "extrapolateSensorPosition",
1798 ),
1799 );
1800 #[cfg(not(feature = "strict"))] Default::default()
1801 }
1802 };
1803 let m_keepFirstSensedHandle = match m_keepFirstSensedHandle {
1804 _serde::__private::Some(__field) => __field,
1805 _serde::__private::None => {
1806 #[cfg(feature = "strict")]
1807 return _serde::__private::Err(
1808 <__A::Error as _serde::de::Error>::missing_field(
1809 "keepFirstSensedHandle",
1810 ),
1811 );
1812 #[cfg(not(feature = "strict"))] Default::default()
1813 }
1814 };
1815 let m_foundHandleOut = match m_foundHandleOut {
1816 _serde::__private::Some(__field) => __field,
1817 _serde::__private::None => {
1818 #[cfg(feature = "strict")]
1819 return _serde::__private::Err(
1820 <__A::Error as _serde::de::Error>::missing_field(
1821 "foundHandleOut",
1822 ),
1823 );
1824 #[cfg(not(feature = "strict"))] Default::default()
1825 }
1826 };
1827 let __ptr = None;
1828 let parent = hkBaseObject { __ptr };
1829 let parent = hkReferencedObject {
1830 __ptr,
1831 parent,
1832 ..Default::default()
1833 };
1834 let parent = hkbBindable {
1835 __ptr,
1836 parent,
1837 m_variableBindingSet,
1838 ..Default::default()
1839 };
1840 let parent = hkbNode {
1841 __ptr,
1842 parent,
1843 m_userData,
1844 m_name,
1845 ..Default::default()
1846 };
1847 let parent = hkbModifier {
1848 __ptr,
1849 parent,
1850 m_enable,
1851 ..Default::default()
1852 };
1853 let __ptr = __A::class_ptr(&mut __map);
1854 _serde::__private::Ok(hkbSenseHandleModifier {
1855 __ptr,
1856 parent,
1857 m_sensorLocalOffset,
1858 m_ranges,
1859 m_handleOut,
1860 m_handleIn,
1861 m_localFrameName,
1862 m_sensorLocalFrameName,
1863 m_minDistance,
1864 m_maxDistance,
1865 m_distanceOut,
1866 m_collisionFilterInfo,
1867 m_sensorRagdollBoneIndex,
1868 m_sensorAnimationBoneIndex,
1869 m_sensingMode,
1870 m_extrapolateSensorPosition,
1871 m_keepFirstSensedHandle,
1872 m_foundHandleOut,
1873 ..Default::default()
1874 })
1875 }
1876 }
1877 const FIELDS: &[&str] = &[
1878 "handle",
1879 "sensorLocalOffset",
1880 "ranges",
1881 "handleOut",
1882 "handleIn",
1883 "localFrameName",
1884 "sensorLocalFrameName",
1885 "minDistance",
1886 "maxDistance",
1887 "distanceOut",
1888 "collisionFilterInfo",
1889 "sensorRagdollBoneIndex",
1890 "sensorAnimationBoneIndex",
1891 "sensingMode",
1892 "extrapolateSensorPosition",
1893 "keepFirstSensedHandle",
1894 "foundHandleOut",
1895 "timeSinceLastModify",
1896 "rangeIndexForEventToSendNextUpdate",
1897 ];
1898 _serde::Deserializer::deserialize_struct(
1899 deserializer,
1900 "hkbSenseHandleModifier",
1901 FIELDS,
1902 __hkbSenseHandleModifierVisitor {
1903 marker: _serde::__private::PhantomData::<hkbSenseHandleModifier>,
1904 lifetime: _serde::__private::PhantomData,
1905 },
1906 )
1907 }
1908 }
1909};
1910#[allow(non_upper_case_globals, non_snake_case)]
1913#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1914#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1915#[derive(
1916 Debug,
1917 Clone,
1918 Default,
1919 PartialEq,
1920 Eq,
1921 PartialOrd,
1922 Ord,
1923 num_derive::ToPrimitive,
1924 num_derive::FromPrimitive,
1925)]
1926pub enum SensingMode {
1927 #[default]
1928 SENSE_IN_NEARBY_RIGID_BODIES = 0isize,
1929 SENSE_IN_RIGID_BODIES_OUTSIDE_THIS_CHARACTER = 1isize,
1930 SENSE_IN_OTHER_CHARACTER_RIGID_BODIES = 2isize,
1931 SENSE_IN_THIS_CHARACTER_RIGID_BODIES = 3isize,
1932 SENSE_IN_GIVEN_CHARACTER_RIGID_BODIES = 4isize,
1933 SENSE_IN_GIVEN_RIGID_BODY = 5isize,
1934 SENSE_IN_OTHER_CHARACTER_SKELETON = 6isize,
1935 SENSE_IN_THIS_CHARACTER_SKELETON = 7isize,
1936 SENSE_IN_GIVEN_CHARACTER_SKELETON = 8isize,
1937 SENSE_IN_GIVEN_LOCAL_FRAME_GROUP = 9isize,
1938}
1939const _: () = {
1940 use havok_serde as __serde;
1941 impl __serde::Serialize for SensingMode {
1942 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1943 where
1944 S: __serde::ser::Serializer,
1945 {
1946 let mut __serializer = __serializer.serialize_enum_flags()?;
1947 match self {
1948 Self::SENSE_IN_NEARBY_RIGID_BODIES => {
1949 __serializer.serialize_field("SENSE_IN_NEARBY_RIGID_BODIES", &0u64)
1950 }
1951 Self::SENSE_IN_RIGID_BODIES_OUTSIDE_THIS_CHARACTER => {
1952 __serializer
1953 .serialize_field(
1954 "SENSE_IN_RIGID_BODIES_OUTSIDE_THIS_CHARACTER",
1955 &1u64,
1956 )
1957 }
1958 Self::SENSE_IN_OTHER_CHARACTER_RIGID_BODIES => {
1959 __serializer
1960 .serialize_field("SENSE_IN_OTHER_CHARACTER_RIGID_BODIES", &2u64)
1961 }
1962 Self::SENSE_IN_THIS_CHARACTER_RIGID_BODIES => {
1963 __serializer
1964 .serialize_field("SENSE_IN_THIS_CHARACTER_RIGID_BODIES", &3u64)
1965 }
1966 Self::SENSE_IN_GIVEN_CHARACTER_RIGID_BODIES => {
1967 __serializer
1968 .serialize_field("SENSE_IN_GIVEN_CHARACTER_RIGID_BODIES", &4u64)
1969 }
1970 Self::SENSE_IN_GIVEN_RIGID_BODY => {
1971 __serializer.serialize_field("SENSE_IN_GIVEN_RIGID_BODY", &5u64)
1972 }
1973 Self::SENSE_IN_OTHER_CHARACTER_SKELETON => {
1974 __serializer
1975 .serialize_field("SENSE_IN_OTHER_CHARACTER_SKELETON", &6u64)
1976 }
1977 Self::SENSE_IN_THIS_CHARACTER_SKELETON => {
1978 __serializer
1979 .serialize_field("SENSE_IN_THIS_CHARACTER_SKELETON", &7u64)
1980 }
1981 Self::SENSE_IN_GIVEN_CHARACTER_SKELETON => {
1982 __serializer
1983 .serialize_field("SENSE_IN_GIVEN_CHARACTER_SKELETON", &8u64)
1984 }
1985 Self::SENSE_IN_GIVEN_LOCAL_FRAME_GROUP => {
1986 __serializer
1987 .serialize_field("SENSE_IN_GIVEN_LOCAL_FRAME_GROUP", &9u64)
1988 }
1989 }?;
1990 use num_traits::ToPrimitive as _;
1991 let num = self
1992 .to_i8()
1993 .ok_or(S::Error::custom("Failed enum SensingMode to_i8"))?;
1994 __serializer.serialize_bits(&num)?;
1995 __serializer.end()
1996 }
1997 }
1998};
1999#[doc(hidden)]
2000#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
2001const _: () = {
2002 #[allow(unused_extern_crates, clippy::useless_attribute)]
2003 extern crate havok_serde as _serde;
2004 #[automatically_derived]
2005 impl<'de> _serde::Deserialize<'de> for SensingMode {
2006 fn deserialize<__D>(
2007 __deserializer: __D,
2008 ) -> _serde::__private::Result<Self, __D::Error>
2009 where
2010 __D: _serde::Deserializer<'de>,
2011 {
2012 #[allow(non_camel_case_types)]
2013 #[doc(hidden)]
2014 enum __Field {
2015 __field0,
2016 __field1,
2017 __field2,
2018 __field3,
2019 __field4,
2020 __field5,
2021 __field6,
2022 __field7,
2023 __field8,
2024 __field9,
2025 }
2026 #[doc(hidden)]
2027 struct __FieldVisitor;
2028 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
2029 type Value = __Field;
2030 fn expecting(
2031 &self,
2032 __formatter: &mut _serde::__private::Formatter,
2033 ) -> _serde::__private::fmt::Result {
2034 _serde::__private::Formatter::write_str(
2035 __formatter,
2036 "variant identifier",
2037 )
2038 }
2039 fn visit_int8<__E>(
2040 self,
2041 __value: i8,
2042 ) -> _serde::__private::Result<Self::Value, __E>
2043 where
2044 __E: _serde::de::Error,
2045 {
2046 match __value {
2047 0i8 => _serde::__private::Ok(__Field::__field0),
2048 1i8 => _serde::__private::Ok(__Field::__field1),
2049 2i8 => _serde::__private::Ok(__Field::__field2),
2050 3i8 => _serde::__private::Ok(__Field::__field3),
2051 4i8 => _serde::__private::Ok(__Field::__field4),
2052 5i8 => _serde::__private::Ok(__Field::__field5),
2053 6i8 => _serde::__private::Ok(__Field::__field6),
2054 7i8 => _serde::__private::Ok(__Field::__field7),
2055 8i8 => _serde::__private::Ok(__Field::__field8),
2056 9i8 => _serde::__private::Ok(__Field::__field9),
2057 _ => {
2058 _serde::__private::Err(
2059 _serde::de::Error::invalid_value(
2060 _serde::de::Unexpected::Int8(__value),
2061 &"value(i8) of variant is one of 0, 1, 2, 3, 4, 5, 6, 7, 8, 9",
2062 ),
2063 )
2064 }
2065 }
2066 }
2067 fn visit_stringptr<__E>(
2068 self,
2069 __value: StringPtr<'de>,
2070 ) -> _serde::__private::Result<Self::Value, __E>
2071 where
2072 __E: _serde::de::Error,
2073 {
2074 if let Some(__value) = __value.into_inner() {
2075 match __value.as_ref() {
2076 v if v == "0"
2077 || v
2078 .eq_ignore_ascii_case("SENSE_IN_NEARBY_RIGID_BODIES") => {
2079 _serde::__private::Ok(__Field::__field0)
2080 }
2081 v if v == "1"
2082 || v
2083 .eq_ignore_ascii_case(
2084 "SENSE_IN_RIGID_BODIES_OUTSIDE_THIS_CHARACTER",
2085 ) => _serde::__private::Ok(__Field::__field1),
2086 v if v == "2"
2087 || v
2088 .eq_ignore_ascii_case(
2089 "SENSE_IN_OTHER_CHARACTER_RIGID_BODIES",
2090 ) => _serde::__private::Ok(__Field::__field2),
2091 v if v == "3"
2092 || v
2093 .eq_ignore_ascii_case(
2094 "SENSE_IN_THIS_CHARACTER_RIGID_BODIES",
2095 ) => _serde::__private::Ok(__Field::__field3),
2096 v if v == "4"
2097 || v
2098 .eq_ignore_ascii_case(
2099 "SENSE_IN_GIVEN_CHARACTER_RIGID_BODIES",
2100 ) => _serde::__private::Ok(__Field::__field4),
2101 v if v == "5"
2102 || v.eq_ignore_ascii_case("SENSE_IN_GIVEN_RIGID_BODY") => {
2103 _serde::__private::Ok(__Field::__field5)
2104 }
2105 v if v == "6"
2106 || v
2107 .eq_ignore_ascii_case(
2108 "SENSE_IN_OTHER_CHARACTER_SKELETON",
2109 ) => _serde::__private::Ok(__Field::__field6),
2110 v if v == "7"
2111 || v
2112 .eq_ignore_ascii_case(
2113 "SENSE_IN_THIS_CHARACTER_SKELETON",
2114 ) => _serde::__private::Ok(__Field::__field7),
2115 v if v == "8"
2116 || v
2117 .eq_ignore_ascii_case(
2118 "SENSE_IN_GIVEN_CHARACTER_SKELETON",
2119 ) => _serde::__private::Ok(__Field::__field8),
2120 v if v == "9"
2121 || v
2122 .eq_ignore_ascii_case(
2123 "SENSE_IN_GIVEN_LOCAL_FRAME_GROUP",
2124 ) => _serde::__private::Ok(__Field::__field9),
2125 _ => {
2126 _serde::__private::Err(
2127 _serde::de::Error::unknown_variant(&__value, VARIANTS),
2128 )
2129 }
2130 }
2131 } else {
2132 _serde::__private::Err(
2133 _serde::de::Error::unknown_variant("None", VARIANTS),
2134 )
2135 }
2136 }
2137 }
2138 impl<'de> _serde::Deserialize<'de> for __Field {
2139 #[inline]
2140 fn deserialize<__D>(
2141 __deserializer: __D,
2142 ) -> _serde::__private::Result<Self, __D::Error>
2143 where
2144 __D: _serde::Deserializer<'de>,
2145 {
2146 _serde::Deserializer::deserialize_identifier(
2147 __deserializer,
2148 _serde::de::ReadEnumSize::Int8,
2149 __FieldVisitor,
2150 )
2151 }
2152 }
2153 #[doc(hidden)]
2154 struct __Visitor<'de> {
2155 marker: _serde::__private::PhantomData<SensingMode>,
2156 lifetime: _serde::__private::PhantomData<&'de ()>,
2157 }
2158 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
2159 type Value = SensingMode;
2160 fn expecting(
2161 &self,
2162 __formatter: &mut _serde::__private::Formatter,
2163 ) -> _serde::__private::fmt::Result {
2164 _serde::__private::Formatter::write_str(
2165 __formatter,
2166 "enum SensingMode",
2167 )
2168 }
2169 fn visit_enum<__A>(
2170 self,
2171 __data: __A,
2172 ) -> _serde::__private::Result<Self::Value, __A::Error>
2173 where
2174 __A: _serde::de::EnumAccess<'de>,
2175 {
2176 match _serde::de::EnumAccess::variant(__data)? {
2177 (__Field::__field0, __variant) => {
2178 _serde::de::VariantAccess::unit_variant(__variant)?;
2179 _serde::__private::Ok(
2180 SensingMode::SENSE_IN_NEARBY_RIGID_BODIES,
2181 )
2182 }
2183 (__Field::__field1, __variant) => {
2184 _serde::de::VariantAccess::unit_variant(__variant)?;
2185 _serde::__private::Ok(
2186 SensingMode::SENSE_IN_RIGID_BODIES_OUTSIDE_THIS_CHARACTER,
2187 )
2188 }
2189 (__Field::__field2, __variant) => {
2190 _serde::de::VariantAccess::unit_variant(__variant)?;
2191 _serde::__private::Ok(
2192 SensingMode::SENSE_IN_OTHER_CHARACTER_RIGID_BODIES,
2193 )
2194 }
2195 (__Field::__field3, __variant) => {
2196 _serde::de::VariantAccess::unit_variant(__variant)?;
2197 _serde::__private::Ok(
2198 SensingMode::SENSE_IN_THIS_CHARACTER_RIGID_BODIES,
2199 )
2200 }
2201 (__Field::__field4, __variant) => {
2202 _serde::de::VariantAccess::unit_variant(__variant)?;
2203 _serde::__private::Ok(
2204 SensingMode::SENSE_IN_GIVEN_CHARACTER_RIGID_BODIES,
2205 )
2206 }
2207 (__Field::__field5, __variant) => {
2208 _serde::de::VariantAccess::unit_variant(__variant)?;
2209 _serde::__private::Ok(SensingMode::SENSE_IN_GIVEN_RIGID_BODY)
2210 }
2211 (__Field::__field6, __variant) => {
2212 _serde::de::VariantAccess::unit_variant(__variant)?;
2213 _serde::__private::Ok(
2214 SensingMode::SENSE_IN_OTHER_CHARACTER_SKELETON,
2215 )
2216 }
2217 (__Field::__field7, __variant) => {
2218 _serde::de::VariantAccess::unit_variant(__variant)?;
2219 _serde::__private::Ok(
2220 SensingMode::SENSE_IN_THIS_CHARACTER_SKELETON,
2221 )
2222 }
2223 (__Field::__field8, __variant) => {
2224 _serde::de::VariantAccess::unit_variant(__variant)?;
2225 _serde::__private::Ok(
2226 SensingMode::SENSE_IN_GIVEN_CHARACTER_SKELETON,
2227 )
2228 }
2229 (__Field::__field9, __variant) => {
2230 _serde::de::VariantAccess::unit_variant(__variant)?;
2231 _serde::__private::Ok(
2232 SensingMode::SENSE_IN_GIVEN_LOCAL_FRAME_GROUP,
2233 )
2234 }
2235 }
2236 }
2237 }
2238 #[doc(hidden)]
2239 const VARIANTS: &'static [&'static str] = &[
2240 "SENSE_IN_NEARBY_RIGID_BODIES",
2241 "SENSE_IN_RIGID_BODIES_OUTSIDE_THIS_CHARACTER",
2242 "SENSE_IN_OTHER_CHARACTER_RIGID_BODIES",
2243 "SENSE_IN_THIS_CHARACTER_RIGID_BODIES",
2244 "SENSE_IN_GIVEN_CHARACTER_RIGID_BODIES",
2245 "SENSE_IN_GIVEN_RIGID_BODY",
2246 "SENSE_IN_OTHER_CHARACTER_SKELETON",
2247 "SENSE_IN_THIS_CHARACTER_SKELETON",
2248 "SENSE_IN_GIVEN_CHARACTER_SKELETON",
2249 "SENSE_IN_GIVEN_LOCAL_FRAME_GROUP",
2250 ];
2251 _serde::Deserializer::deserialize_enum(
2252 __deserializer,
2253 "SensingMode",
2254 VARIANTS,
2255 __Visitor {
2256 marker: _serde::__private::PhantomData::<SensingMode>,
2257 lifetime: _serde::__private::PhantomData,
2258 },
2259 )
2260 }
2261 }
2262};