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