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 BSLookAtModifier<'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 = "lookAtTarget"))]
36 #[cfg_attr(feature = "serde", serde(rename = "lookAtTarget"))]
37 pub m_lookAtTarget: bool,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "bones"))]
43 #[cfg_attr(feature = "serde", serde(rename = "bones"))]
44 pub m_bones: Vec<BSLookAtModifierBoneData>,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "eyeBones"))]
50 #[cfg_attr(feature = "serde", serde(rename = "eyeBones"))]
51 pub m_eyeBones: Vec<BSLookAtModifierBoneData>,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "limitAngleDegrees"))]
57 #[cfg_attr(feature = "serde", serde(rename = "limitAngleDegrees"))]
58 pub m_limitAngleDegrees: f32,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "limitAngleThresholdDegrees"))]
64 #[cfg_attr(feature = "serde", serde(rename = "limitAngleThresholdDegrees"))]
65 pub m_limitAngleThresholdDegrees: f32,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "continueLookOutsideOfLimit"))]
71 #[cfg_attr(feature = "serde", serde(rename = "continueLookOutsideOfLimit"))]
72 pub m_continueLookOutsideOfLimit: bool,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "onGain"))]
78 #[cfg_attr(feature = "serde", serde(rename = "onGain"))]
79 pub m_onGain: f32,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "offGain"))]
85 #[cfg_attr(feature = "serde", serde(rename = "offGain"))]
86 pub m_offGain: f32,
87 #[cfg_attr(feature = "json_schema", schemars(rename = "useBoneGains"))]
92 #[cfg_attr(feature = "serde", serde(rename = "useBoneGains"))]
93 pub m_useBoneGains: bool,
94 #[cfg_attr(feature = "json_schema", schemars(rename = "targetLocation"))]
99 #[cfg_attr(feature = "serde", serde(rename = "targetLocation"))]
100 pub m_targetLocation: Vector4,
101 #[cfg_attr(feature = "json_schema", schemars(rename = "targetOutsideLimits"))]
106 #[cfg_attr(feature = "serde", serde(rename = "targetOutsideLimits"))]
107 pub m_targetOutsideLimits: bool,
108 #[cfg_attr(feature = "json_schema", schemars(rename = "targetOutOfLimitEvent"))]
113 #[cfg_attr(feature = "serde", serde(rename = "targetOutOfLimitEvent"))]
114 pub m_targetOutOfLimitEvent: hkbEventProperty,
115 #[cfg_attr(feature = "json_schema", schemars(rename = "lookAtCamera"))]
120 #[cfg_attr(feature = "serde", serde(rename = "lookAtCamera"))]
121 pub m_lookAtCamera: bool,
122 #[cfg_attr(feature = "json_schema", schemars(rename = "lookAtCameraX"))]
127 #[cfg_attr(feature = "serde", serde(rename = "lookAtCameraX"))]
128 pub m_lookAtCameraX: f32,
129 #[cfg_attr(feature = "json_schema", schemars(rename = "lookAtCameraY"))]
134 #[cfg_attr(feature = "serde", serde(rename = "lookAtCameraY"))]
135 pub m_lookAtCameraY: f32,
136 #[cfg_attr(feature = "json_schema", schemars(rename = "lookAtCameraZ"))]
141 #[cfg_attr(feature = "serde", serde(rename = "lookAtCameraZ"))]
142 pub m_lookAtCameraZ: f32,
143 #[cfg_attr(feature = "json_schema", schemars(rename = "timeStep"))]
149 #[cfg_attr(feature = "serde", serde(rename = "timeStep"))]
150 pub m_timeStep: f32,
151 #[cfg_attr(feature = "json_schema", schemars(rename = "ballBonesValid"))]
157 #[cfg_attr(feature = "serde", serde(rename = "ballBonesValid"))]
158 pub m_ballBonesValid: bool,
159 #[cfg_attr(feature = "json_schema", schemars(rename = "pSkeletonMemory"))]
165 #[cfg_attr(feature = "serde", serde(rename = "pSkeletonMemory"))]
166 pub m_pSkeletonMemory: Pointer,
167}
168const _: () = {
169 use havok_serde as _serde;
170 impl<'a> _serde::HavokClass for BSLookAtModifier<'a> {
171 #[inline]
172 fn name(&self) -> &'static str {
173 "BSLookAtModifier"
174 }
175 #[inline]
176 fn signature(&self) -> _serde::__private::Signature {
177 _serde::__private::Signature::new(0xd756fc25)
178 }
179 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
180 fn deps_indexes(&self) -> Vec<usize> {
181 let mut v = Vec::new();
182 v.push(self.parent.parent.parent.m_variableBindingSet.get());
183 v.extend(
184 self
185 .m_bones
186 .iter()
187 .flat_map(|class| class.deps_indexes())
188 .collect::<Vec<usize>>(),
189 );
190 v.extend(
191 self
192 .m_eyeBones
193 .iter()
194 .flat_map(|class| class.deps_indexes())
195 .collect::<Vec<usize>>(),
196 );
197 v.extend(self.m_targetOutOfLimitEvent.deps_indexes());
198 v.push(self.m_pSkeletonMemory.get());
199 v
200 }
201 }
202 impl<'a> _serde::Serialize for BSLookAtModifier<'a> {
203 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
204 where
205 S: _serde::ser::Serializer,
206 {
207 let class_meta = self
208 .__ptr
209 .map(|name| (name, _serde::__private::Signature::new(0xd756fc25)));
210 let mut serializer = __serializer
211 .serialize_struct("BSLookAtModifier", class_meta, (160u64, 224u64))?;
212 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
213 serializer
214 .skip_field(
215 "memSizeAndFlags",
216 &self.parent.parent.parent.parent.m_memSizeAndFlags,
217 )?;
218 serializer
219 .skip_field(
220 "referenceCount",
221 &self.parent.parent.parent.parent.m_referenceCount,
222 )?;
223 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
224 serializer
225 .serialize_field(
226 "variableBindingSet",
227 &self.parent.parent.parent.m_variableBindingSet,
228 )?;
229 serializer
230 .skip_array_field(
231 "cachedBindables",
232 &self.parent.parent.parent.m_cachedBindables,
233 TypeSize::NonPtr,
234 )?;
235 serializer
236 .skip_field(
237 "areBindablesCached",
238 &self.parent.parent.parent.m_areBindablesCached,
239 )?;
240 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
241 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
242 serializer.serialize_field("name", &self.parent.parent.m_name)?;
243 serializer.skip_field("id", &self.parent.parent.m_id)?;
244 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
245 serializer
246 .skip_fixed_array_field(
247 "padNode",
248 self.parent.parent.m_padNode.as_slice(),
249 TypeSize::NonPtr,
250 )?;
251 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
252 serializer.serialize_field("enable", &self.parent.m_enable)?;
253 serializer
254 .skip_fixed_array_field(
255 "padModifier",
256 self.parent.m_padModifier.as_slice(),
257 TypeSize::NonPtr,
258 )?;
259 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
260 serializer.serialize_field("lookAtTarget", &self.m_lookAtTarget)?;
261 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
262 serializer
263 .serialize_array_field(
264 "bones",
265 &self.m_bones,
266 TypeSize::Struct {
267 size_x86: 64u64,
268 size_x86_64: 64u64,
269 },
270 )?;
271 serializer
272 .serialize_array_field(
273 "eyeBones",
274 &self.m_eyeBones,
275 TypeSize::Struct {
276 size_x86: 64u64,
277 size_x86_64: 64u64,
278 },
279 )?;
280 serializer.serialize_field("limitAngleDegrees", &self.m_limitAngleDegrees)?;
281 serializer
282 .serialize_field(
283 "limitAngleThresholdDegrees",
284 &self.m_limitAngleThresholdDegrees,
285 )?;
286 serializer
287 .serialize_field(
288 "continueLookOutsideOfLimit",
289 &self.m_continueLookOutsideOfLimit,
290 )?;
291 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
292 serializer.serialize_field("onGain", &self.m_onGain)?;
293 serializer.serialize_field("offGain", &self.m_offGain)?;
294 serializer.serialize_field("useBoneGains", &self.m_useBoneGains)?;
295 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
296 serializer.serialize_field("targetLocation", &self.m_targetLocation)?;
297 serializer
298 .serialize_field("targetOutsideLimits", &self.m_targetOutsideLimits)?;
299 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
300 serializer
301 .serialize_field(
302 "targetOutOfLimitEvent",
303 &self.m_targetOutOfLimitEvent,
304 )?;
305 serializer.serialize_field("lookAtCamera", &self.m_lookAtCamera)?;
306 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
307 serializer.serialize_field("lookAtCameraX", &self.m_lookAtCameraX)?;
308 serializer.serialize_field("lookAtCameraY", &self.m_lookAtCameraY)?;
309 serializer.serialize_field("lookAtCameraZ", &self.m_lookAtCameraZ)?;
310 serializer.skip_field("timeStep", &self.m_timeStep)?;
311 serializer.skip_field("ballBonesValid", &self.m_ballBonesValid)?;
312 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
313 serializer.skip_field("pSkeletonMemory", &self.m_pSkeletonMemory)?;
314 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 8usize].as_slice())?;
315 serializer.end()
316 }
317 }
318};
319#[doc(hidden)]
320#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
321const _: () = {
322 use havok_serde as _serde;
323 #[automatically_derived]
324 impl<'de> _serde::Deserialize<'de> for BSLookAtModifier<'de> {
325 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
326 where
327 __D: _serde::Deserializer<'de>,
328 {
329 #[allow(non_camel_case_types)]
330 enum __Field {
331 m_variableBindingSet,
332 m_userData,
333 m_name,
334 m_enable,
335 m_lookAtTarget,
336 m_bones,
337 m_eyeBones,
338 m_limitAngleDegrees,
339 m_limitAngleThresholdDegrees,
340 m_continueLookOutsideOfLimit,
341 m_onGain,
342 m_offGain,
343 m_useBoneGains,
344 m_targetLocation,
345 m_targetOutsideLimits,
346 m_targetOutOfLimitEvent,
347 m_lookAtCamera,
348 m_lookAtCameraX,
349 m_lookAtCameraY,
350 m_lookAtCameraZ,
351 __ignore,
352 }
353 struct __FieldVisitor;
354 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
355 type Value = __Field;
356 fn expecting(
357 &self,
358 __formatter: &mut core::fmt::Formatter,
359 ) -> core::fmt::Result {
360 core::fmt::Formatter::write_str(__formatter, "field identifier")
361 }
362 #[allow(clippy::match_single_binding)]
364 #[allow(clippy::reversed_empty_ranges)]
365 #[allow(clippy::single_match)]
366 fn visit_key<__E>(
367 self,
368 __value: &str,
369 ) -> core::result::Result<Self::Value, __E>
370 where
371 __E: _serde::de::Error,
372 {
373 match __value {
374 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
375 "userData" => Ok(__Field::m_userData),
376 "name" => Ok(__Field::m_name),
377 "enable" => Ok(__Field::m_enable),
378 "lookAtTarget" => Ok(__Field::m_lookAtTarget),
379 "bones" => Ok(__Field::m_bones),
380 "eyeBones" => Ok(__Field::m_eyeBones),
381 "limitAngleDegrees" => Ok(__Field::m_limitAngleDegrees),
382 "limitAngleThresholdDegrees" => {
383 Ok(__Field::m_limitAngleThresholdDegrees)
384 }
385 "continueLookOutsideOfLimit" => {
386 Ok(__Field::m_continueLookOutsideOfLimit)
387 }
388 "onGain" => Ok(__Field::m_onGain),
389 "offGain" => Ok(__Field::m_offGain),
390 "useBoneGains" => Ok(__Field::m_useBoneGains),
391 "targetLocation" => Ok(__Field::m_targetLocation),
392 "targetOutsideLimits" => Ok(__Field::m_targetOutsideLimits),
393 "targetOutOfLimitEvent" => Ok(__Field::m_targetOutOfLimitEvent),
394 "lookAtCamera" => Ok(__Field::m_lookAtCamera),
395 "lookAtCameraX" => Ok(__Field::m_lookAtCameraX),
396 "lookAtCameraY" => Ok(__Field::m_lookAtCameraY),
397 "lookAtCameraZ" => Ok(__Field::m_lookAtCameraZ),
398 _ => Ok(__Field::__ignore),
399 }
400 }
401 }
402 impl<'de> _serde::Deserialize<'de> for __Field {
403 #[inline]
404 fn deserialize<__D>(
405 __deserializer: __D,
406 ) -> core::result::Result<Self, __D::Error>
407 where
408 __D: _serde::Deserializer<'de>,
409 {
410 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
411 }
412 }
413 struct __BSLookAtModifierVisitor<'de> {
414 marker: _serde::__private::PhantomData<BSLookAtModifier<'de>>,
415 lifetime: _serde::__private::PhantomData<&'de ()>,
416 }
417 #[allow(clippy::match_single_binding)]
418 #[allow(clippy::reversed_empty_ranges)]
419 #[allow(clippy::single_match)]
420 impl<'de> _serde::de::Visitor<'de> for __BSLookAtModifierVisitor<'de> {
421 type Value = BSLookAtModifier<'de>;
422 fn expecting(
423 &self,
424 __formatter: &mut core::fmt::Formatter,
425 ) -> core::fmt::Result {
426 core::fmt::Formatter::write_str(
427 __formatter,
428 "struct BSLookAtModifier",
429 )
430 }
431 fn visit_struct_for_bytes<__A>(
432 self,
433 mut __map: __A,
434 ) -> _serde::__private::Result<Self::Value, __A::Error>
435 where
436 __A: _serde::de::MapAccess<'de>,
437 {
438 let __ptr = __A::class_ptr(&mut __map);
439 let parent = __A::parent_value(&mut __map)?;
440 let mut m_lookAtTarget: _serde::__private::Option<bool> = _serde::__private::None;
441 let mut m_bones: _serde::__private::Option<
442 Vec<BSLookAtModifierBoneData>,
443 > = _serde::__private::None;
444 let mut m_eyeBones: _serde::__private::Option<
445 Vec<BSLookAtModifierBoneData>,
446 > = _serde::__private::None;
447 let mut m_limitAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
448 let mut m_limitAngleThresholdDegrees: _serde::__private::Option<
449 f32,
450 > = _serde::__private::None;
451 let mut m_continueLookOutsideOfLimit: _serde::__private::Option<
452 bool,
453 > = _serde::__private::None;
454 let mut m_onGain: _serde::__private::Option<f32> = _serde::__private::None;
455 let mut m_offGain: _serde::__private::Option<f32> = _serde::__private::None;
456 let mut m_useBoneGains: _serde::__private::Option<bool> = _serde::__private::None;
457 let mut m_targetLocation: _serde::__private::Option<Vector4> = _serde::__private::None;
458 let mut m_targetOutsideLimits: _serde::__private::Option<bool> = _serde::__private::None;
459 let mut m_targetOutOfLimitEvent: _serde::__private::Option<
460 hkbEventProperty,
461 > = _serde::__private::None;
462 let mut m_lookAtCamera: _serde::__private::Option<bool> = _serde::__private::None;
463 let mut m_lookAtCameraX: _serde::__private::Option<f32> = _serde::__private::None;
464 let mut m_lookAtCameraY: _serde::__private::Option<f32> = _serde::__private::None;
465 let mut m_lookAtCameraZ: _serde::__private::Option<f32> = _serde::__private::None;
466 let mut m_timeStep: _serde::__private::Option<f32> = _serde::__private::None;
467 let mut m_ballBonesValid: _serde::__private::Option<bool> = _serde::__private::None;
468 let mut m_pSkeletonMemory: _serde::__private::Option<Pointer> = _serde::__private::None;
469 for i in 0..19usize {
470 match i {
471 0usize => {
472 if _serde::__private::Option::is_some(&m_lookAtTarget) {
473 return _serde::__private::Err(
474 <__A::Error as _serde::de::Error>::duplicate_field(
475 "lookAtTarget",
476 ),
477 );
478 }
479 m_lookAtTarget = _serde::__private::Some(
480 match __A::next_value::<bool>(&mut __map) {
481 _serde::__private::Ok(__val) => __val,
482 _serde::__private::Err(__err) => {
483 return _serde::__private::Err(__err);
484 }
485 },
486 );
487 }
488 1usize => {
489 if _serde::__private::Option::is_some(&m_bones) {
490 return _serde::__private::Err(
491 <__A::Error as _serde::de::Error>::duplicate_field("bones"),
492 );
493 }
494 __A::pad(&mut __map, 3usize, 7usize)?;
495 m_bones = _serde::__private::Some(
496 match __A::next_value::<
497 Vec<BSLookAtModifierBoneData>,
498 >(&mut __map) {
499 _serde::__private::Ok(__val) => __val,
500 _serde::__private::Err(__err) => {
501 return _serde::__private::Err(__err);
502 }
503 },
504 );
505 }
506 2usize => {
507 if _serde::__private::Option::is_some(&m_eyeBones) {
508 return _serde::__private::Err(
509 <__A::Error as _serde::de::Error>::duplicate_field(
510 "eyeBones",
511 ),
512 );
513 }
514 m_eyeBones = _serde::__private::Some(
515 match __A::next_value::<
516 Vec<BSLookAtModifierBoneData>,
517 >(&mut __map) {
518 _serde::__private::Ok(__val) => __val,
519 _serde::__private::Err(__err) => {
520 return _serde::__private::Err(__err);
521 }
522 },
523 );
524 }
525 3usize => {
526 if _serde::__private::Option::is_some(
527 &m_limitAngleDegrees,
528 ) {
529 return _serde::__private::Err(
530 <__A::Error as _serde::de::Error>::duplicate_field(
531 "limitAngleDegrees",
532 ),
533 );
534 }
535 m_limitAngleDegrees = _serde::__private::Some(
536 match __A::next_value::<f32>(&mut __map) {
537 _serde::__private::Ok(__val) => __val,
538 _serde::__private::Err(__err) => {
539 return _serde::__private::Err(__err);
540 }
541 },
542 );
543 }
544 4usize => {
545 if _serde::__private::Option::is_some(
546 &m_limitAngleThresholdDegrees,
547 ) {
548 return _serde::__private::Err(
549 <__A::Error as _serde::de::Error>::duplicate_field(
550 "limitAngleThresholdDegrees",
551 ),
552 );
553 }
554 m_limitAngleThresholdDegrees = _serde::__private::Some(
555 match __A::next_value::<f32>(&mut __map) {
556 _serde::__private::Ok(__val) => __val,
557 _serde::__private::Err(__err) => {
558 return _serde::__private::Err(__err);
559 }
560 },
561 );
562 }
563 5usize => {
564 if _serde::__private::Option::is_some(
565 &m_continueLookOutsideOfLimit,
566 ) {
567 return _serde::__private::Err(
568 <__A::Error as _serde::de::Error>::duplicate_field(
569 "continueLookOutsideOfLimit",
570 ),
571 );
572 }
573 m_continueLookOutsideOfLimit = _serde::__private::Some(
574 match __A::next_value::<bool>(&mut __map) {
575 _serde::__private::Ok(__val) => __val,
576 _serde::__private::Err(__err) => {
577 return _serde::__private::Err(__err);
578 }
579 },
580 );
581 }
582 6usize => {
583 if _serde::__private::Option::is_some(&m_onGain) {
584 return _serde::__private::Err(
585 <__A::Error as _serde::de::Error>::duplicate_field("onGain"),
586 );
587 }
588 __A::pad(&mut __map, 3usize, 3usize)?;
589 m_onGain = _serde::__private::Some(
590 match __A::next_value::<f32>(&mut __map) {
591 _serde::__private::Ok(__val) => __val,
592 _serde::__private::Err(__err) => {
593 return _serde::__private::Err(__err);
594 }
595 },
596 );
597 }
598 7usize => {
599 if _serde::__private::Option::is_some(&m_offGain) {
600 return _serde::__private::Err(
601 <__A::Error as _serde::de::Error>::duplicate_field(
602 "offGain",
603 ),
604 );
605 }
606 m_offGain = _serde::__private::Some(
607 match __A::next_value::<f32>(&mut __map) {
608 _serde::__private::Ok(__val) => __val,
609 _serde::__private::Err(__err) => {
610 return _serde::__private::Err(__err);
611 }
612 },
613 );
614 }
615 8usize => {
616 if _serde::__private::Option::is_some(&m_useBoneGains) {
617 return _serde::__private::Err(
618 <__A::Error as _serde::de::Error>::duplicate_field(
619 "useBoneGains",
620 ),
621 );
622 }
623 m_useBoneGains = _serde::__private::Some(
624 match __A::next_value::<bool>(&mut __map) {
625 _serde::__private::Ok(__val) => __val,
626 _serde::__private::Err(__err) => {
627 return _serde::__private::Err(__err);
628 }
629 },
630 );
631 }
632 9usize => {
633 if _serde::__private::Option::is_some(&m_targetLocation) {
634 return _serde::__private::Err(
635 <__A::Error as _serde::de::Error>::duplicate_field(
636 "targetLocation",
637 ),
638 );
639 }
640 __A::pad(&mut __map, 3usize, 3usize)?;
641 m_targetLocation = _serde::__private::Some(
642 match __A::next_value::<Vector4>(&mut __map) {
643 _serde::__private::Ok(__val) => __val,
644 _serde::__private::Err(__err) => {
645 return _serde::__private::Err(__err);
646 }
647 },
648 );
649 }
650 10usize => {
651 if _serde::__private::Option::is_some(
652 &m_targetOutsideLimits,
653 ) {
654 return _serde::__private::Err(
655 <__A::Error as _serde::de::Error>::duplicate_field(
656 "targetOutsideLimits",
657 ),
658 );
659 }
660 m_targetOutsideLimits = _serde::__private::Some(
661 match __A::next_value::<bool>(&mut __map) {
662 _serde::__private::Ok(__val) => __val,
663 _serde::__private::Err(__err) => {
664 return _serde::__private::Err(__err);
665 }
666 },
667 );
668 }
669 11usize => {
670 if _serde::__private::Option::is_some(
671 &m_targetOutOfLimitEvent,
672 ) {
673 return _serde::__private::Err(
674 <__A::Error as _serde::de::Error>::duplicate_field(
675 "targetOutOfLimitEvent",
676 ),
677 );
678 }
679 __A::pad(&mut __map, 3usize, 7usize)?;
680 m_targetOutOfLimitEvent = _serde::__private::Some(
681 match __A::next_value::<hkbEventProperty>(&mut __map) {
682 _serde::__private::Ok(__val) => __val,
683 _serde::__private::Err(__err) => {
684 return _serde::__private::Err(__err);
685 }
686 },
687 );
688 }
689 12usize => {
690 if _serde::__private::Option::is_some(&m_lookAtCamera) {
691 return _serde::__private::Err(
692 <__A::Error as _serde::de::Error>::duplicate_field(
693 "lookAtCamera",
694 ),
695 );
696 }
697 m_lookAtCamera = _serde::__private::Some(
698 match __A::next_value::<bool>(&mut __map) {
699 _serde::__private::Ok(__val) => __val,
700 _serde::__private::Err(__err) => {
701 return _serde::__private::Err(__err);
702 }
703 },
704 );
705 }
706 13usize => {
707 if _serde::__private::Option::is_some(&m_lookAtCameraX) {
708 return _serde::__private::Err(
709 <__A::Error as _serde::de::Error>::duplicate_field(
710 "lookAtCameraX",
711 ),
712 );
713 }
714 __A::pad(&mut __map, 3usize, 3usize)?;
715 m_lookAtCameraX = _serde::__private::Some(
716 match __A::next_value::<f32>(&mut __map) {
717 _serde::__private::Ok(__val) => __val,
718 _serde::__private::Err(__err) => {
719 return _serde::__private::Err(__err);
720 }
721 },
722 );
723 }
724 14usize => {
725 if _serde::__private::Option::is_some(&m_lookAtCameraY) {
726 return _serde::__private::Err(
727 <__A::Error as _serde::de::Error>::duplicate_field(
728 "lookAtCameraY",
729 ),
730 );
731 }
732 m_lookAtCameraY = _serde::__private::Some(
733 match __A::next_value::<f32>(&mut __map) {
734 _serde::__private::Ok(__val) => __val,
735 _serde::__private::Err(__err) => {
736 return _serde::__private::Err(__err);
737 }
738 },
739 );
740 }
741 15usize => {
742 if _serde::__private::Option::is_some(&m_lookAtCameraZ) {
743 return _serde::__private::Err(
744 <__A::Error as _serde::de::Error>::duplicate_field(
745 "lookAtCameraZ",
746 ),
747 );
748 }
749 m_lookAtCameraZ = _serde::__private::Some(
750 match __A::next_value::<f32>(&mut __map) {
751 _serde::__private::Ok(__val) => __val,
752 _serde::__private::Err(__err) => {
753 return _serde::__private::Err(__err);
754 }
755 },
756 );
757 }
758 16usize => {
759 if _serde::__private::Option::is_some(&m_timeStep) {
760 return _serde::__private::Err(
761 <__A::Error as _serde::de::Error>::duplicate_field(
762 "timeStep",
763 ),
764 );
765 }
766 m_timeStep = _serde::__private::Some(
767 match __A::next_value::<f32>(&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(&m_ballBonesValid) {
777 return _serde::__private::Err(
778 <__A::Error as _serde::de::Error>::duplicate_field(
779 "ballBonesValid",
780 ),
781 );
782 }
783 m_ballBonesValid = _serde::__private::Some(
784 match __A::next_value::<bool>(&mut __map) {
785 _serde::__private::Ok(__val) => __val,
786 _serde::__private::Err(__err) => {
787 return _serde::__private::Err(__err);
788 }
789 },
790 );
791 }
792 18usize => {
793 if _serde::__private::Option::is_some(&m_pSkeletonMemory) {
794 return _serde::__private::Err(
795 <__A::Error as _serde::de::Error>::duplicate_field(
796 "pSkeletonMemory",
797 ),
798 );
799 }
800 __A::pad(&mut __map, 3usize, 3usize)?;
801 m_pSkeletonMemory = _serde::__private::Some(
802 match __A::next_value::<Pointer>(&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, 8usize, 8usize)?;
814 let m_lookAtTarget = match m_lookAtTarget {
815 _serde::__private::Some(__field) => __field,
816 _serde::__private::None => {
817 return _serde::__private::Err(
818 <__A::Error as _serde::de::Error>::missing_field(
819 "lookAtTarget",
820 ),
821 );
822 }
823 };
824 let m_bones = match m_bones {
825 _serde::__private::Some(__field) => __field,
826 _serde::__private::None => {
827 return _serde::__private::Err(
828 <__A::Error as _serde::de::Error>::missing_field("bones"),
829 );
830 }
831 };
832 let m_eyeBones = match m_eyeBones {
833 _serde::__private::Some(__field) => __field,
834 _serde::__private::None => {
835 return _serde::__private::Err(
836 <__A::Error as _serde::de::Error>::missing_field("eyeBones"),
837 );
838 }
839 };
840 let m_limitAngleDegrees = match m_limitAngleDegrees {
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 "limitAngleDegrees",
846 ),
847 );
848 }
849 };
850 let m_limitAngleThresholdDegrees = match m_limitAngleThresholdDegrees {
851 _serde::__private::Some(__field) => __field,
852 _serde::__private::None => {
853 return _serde::__private::Err(
854 <__A::Error as _serde::de::Error>::missing_field(
855 "limitAngleThresholdDegrees",
856 ),
857 );
858 }
859 };
860 let m_continueLookOutsideOfLimit = match m_continueLookOutsideOfLimit {
861 _serde::__private::Some(__field) => __field,
862 _serde::__private::None => {
863 return _serde::__private::Err(
864 <__A::Error as _serde::de::Error>::missing_field(
865 "continueLookOutsideOfLimit",
866 ),
867 );
868 }
869 };
870 let m_onGain = match m_onGain {
871 _serde::__private::Some(__field) => __field,
872 _serde::__private::None => {
873 return _serde::__private::Err(
874 <__A::Error as _serde::de::Error>::missing_field("onGain"),
875 );
876 }
877 };
878 let m_offGain = match m_offGain {
879 _serde::__private::Some(__field) => __field,
880 _serde::__private::None => {
881 return _serde::__private::Err(
882 <__A::Error as _serde::de::Error>::missing_field("offGain"),
883 );
884 }
885 };
886 let m_useBoneGains = match m_useBoneGains {
887 _serde::__private::Some(__field) => __field,
888 _serde::__private::None => {
889 return _serde::__private::Err(
890 <__A::Error as _serde::de::Error>::missing_field(
891 "useBoneGains",
892 ),
893 );
894 }
895 };
896 let m_targetLocation = match m_targetLocation {
897 _serde::__private::Some(__field) => __field,
898 _serde::__private::None => {
899 return _serde::__private::Err(
900 <__A::Error as _serde::de::Error>::missing_field(
901 "targetLocation",
902 ),
903 );
904 }
905 };
906 let m_targetOutsideLimits = match m_targetOutsideLimits {
907 _serde::__private::Some(__field) => __field,
908 _serde::__private::None => {
909 return _serde::__private::Err(
910 <__A::Error as _serde::de::Error>::missing_field(
911 "targetOutsideLimits",
912 ),
913 );
914 }
915 };
916 let m_targetOutOfLimitEvent = match m_targetOutOfLimitEvent {
917 _serde::__private::Some(__field) => __field,
918 _serde::__private::None => {
919 return _serde::__private::Err(
920 <__A::Error as _serde::de::Error>::missing_field(
921 "targetOutOfLimitEvent",
922 ),
923 );
924 }
925 };
926 let m_lookAtCamera = match m_lookAtCamera {
927 _serde::__private::Some(__field) => __field,
928 _serde::__private::None => {
929 return _serde::__private::Err(
930 <__A::Error as _serde::de::Error>::missing_field(
931 "lookAtCamera",
932 ),
933 );
934 }
935 };
936 let m_lookAtCameraX = match m_lookAtCameraX {
937 _serde::__private::Some(__field) => __field,
938 _serde::__private::None => {
939 return _serde::__private::Err(
940 <__A::Error as _serde::de::Error>::missing_field(
941 "lookAtCameraX",
942 ),
943 );
944 }
945 };
946 let m_lookAtCameraY = match m_lookAtCameraY {
947 _serde::__private::Some(__field) => __field,
948 _serde::__private::None => {
949 return _serde::__private::Err(
950 <__A::Error as _serde::de::Error>::missing_field(
951 "lookAtCameraY",
952 ),
953 );
954 }
955 };
956 let m_lookAtCameraZ = match m_lookAtCameraZ {
957 _serde::__private::Some(__field) => __field,
958 _serde::__private::None => {
959 return _serde::__private::Err(
960 <__A::Error as _serde::de::Error>::missing_field(
961 "lookAtCameraZ",
962 ),
963 );
964 }
965 };
966 let m_timeStep = match m_timeStep {
967 _serde::__private::Some(__field) => __field,
968 _serde::__private::None => {
969 return _serde::__private::Err(
970 <__A::Error as _serde::de::Error>::missing_field("timeStep"),
971 );
972 }
973 };
974 let m_ballBonesValid = match m_ballBonesValid {
975 _serde::__private::Some(__field) => __field,
976 _serde::__private::None => {
977 return _serde::__private::Err(
978 <__A::Error as _serde::de::Error>::missing_field(
979 "ballBonesValid",
980 ),
981 );
982 }
983 };
984 let m_pSkeletonMemory = match m_pSkeletonMemory {
985 _serde::__private::Some(__field) => __field,
986 _serde::__private::None => {
987 return _serde::__private::Err(
988 <__A::Error as _serde::de::Error>::missing_field(
989 "pSkeletonMemory",
990 ),
991 );
992 }
993 };
994 _serde::__private::Ok(BSLookAtModifier {
995 __ptr,
996 parent,
997 m_lookAtTarget,
998 m_bones,
999 m_eyeBones,
1000 m_limitAngleDegrees,
1001 m_limitAngleThresholdDegrees,
1002 m_continueLookOutsideOfLimit,
1003 m_onGain,
1004 m_offGain,
1005 m_useBoneGains,
1006 m_targetLocation,
1007 m_targetOutsideLimits,
1008 m_targetOutOfLimitEvent,
1009 m_lookAtCamera,
1010 m_lookAtCameraX,
1011 m_lookAtCameraY,
1012 m_lookAtCameraZ,
1013 m_timeStep,
1014 m_ballBonesValid,
1015 m_pSkeletonMemory,
1016 })
1017 }
1018 #[allow(clippy::manual_unwrap_or_default)]
1019 fn visit_struct<__A>(
1020 self,
1021 mut __map: __A,
1022 ) -> _serde::__private::Result<Self::Value, __A::Error>
1023 where
1024 __A: _serde::de::MapAccess<'de>,
1025 {
1026 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
1027 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1028 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1029 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
1030 let mut m_lookAtTarget: _serde::__private::Option<bool> = _serde::__private::None;
1031 let mut m_bones: _serde::__private::Option<
1032 Vec<BSLookAtModifierBoneData>,
1033 > = _serde::__private::None;
1034 let mut m_eyeBones: _serde::__private::Option<
1035 Vec<BSLookAtModifierBoneData>,
1036 > = _serde::__private::None;
1037 let mut m_limitAngleDegrees: _serde::__private::Option<f32> = _serde::__private::None;
1038 let mut m_limitAngleThresholdDegrees: _serde::__private::Option<
1039 f32,
1040 > = _serde::__private::None;
1041 let mut m_continueLookOutsideOfLimit: _serde::__private::Option<
1042 bool,
1043 > = _serde::__private::None;
1044 let mut m_onGain: _serde::__private::Option<f32> = _serde::__private::None;
1045 let mut m_offGain: _serde::__private::Option<f32> = _serde::__private::None;
1046 let mut m_useBoneGains: _serde::__private::Option<bool> = _serde::__private::None;
1047 let mut m_targetLocation: _serde::__private::Option<Vector4> = _serde::__private::None;
1048 let mut m_targetOutsideLimits: _serde::__private::Option<bool> = _serde::__private::None;
1049 let mut m_targetOutOfLimitEvent: _serde::__private::Option<
1050 hkbEventProperty,
1051 > = _serde::__private::None;
1052 let mut m_lookAtCamera: _serde::__private::Option<bool> = _serde::__private::None;
1053 let mut m_lookAtCameraX: _serde::__private::Option<f32> = _serde::__private::None;
1054 let mut m_lookAtCameraY: _serde::__private::Option<f32> = _serde::__private::None;
1055 let mut m_lookAtCameraZ: _serde::__private::Option<f32> = _serde::__private::None;
1056 while let _serde::__private::Some(__key) = {
1057 __A::next_key::<__Field>(&mut __map)?
1058 } {
1059 match __key {
1060 __Field::m_variableBindingSet => {
1061 #[cfg(
1062 any(feature = "strict", feature = "ignore_duplicates")
1063 )]
1064 if _serde::__private::Option::is_some(
1065 &m_variableBindingSet,
1066 ) {
1067 #[cfg(feature = "ignore_duplicates")]
1068 {
1069 __A::skip_value(&mut __map)?;
1070 continue;
1071 }
1072 #[cfg(feature = "strict")]
1073 return _serde::__private::Err(
1074 <__A::Error as _serde::de::Error>::duplicate_field(
1075 "variableBindingSet",
1076 ),
1077 );
1078 }
1079 m_variableBindingSet = _serde::__private::Some(
1080 match __A::next_value::<Pointer>(&mut __map) {
1081 _serde::__private::Ok(__val) => __val,
1082 _serde::__private::Err(__err) => {
1083 return _serde::__private::Err(__err);
1084 }
1085 },
1086 );
1087 }
1088 __Field::m_userData => {
1089 #[cfg(
1090 any(feature = "strict", feature = "ignore_duplicates")
1091 )]
1092 if _serde::__private::Option::is_some(&m_userData) {
1093 #[cfg(feature = "ignore_duplicates")]
1094 {
1095 __A::skip_value(&mut __map)?;
1096 continue;
1097 }
1098 #[cfg(feature = "strict")]
1099 return _serde::__private::Err(
1100 <__A::Error as _serde::de::Error>::duplicate_field(
1101 "userData",
1102 ),
1103 );
1104 }
1105 m_userData = _serde::__private::Some(
1106 match __A::next_value::<Ulong>(&mut __map) {
1107 _serde::__private::Ok(__val) => __val,
1108 _serde::__private::Err(__err) => {
1109 return _serde::__private::Err(__err);
1110 }
1111 },
1112 );
1113 }
1114 __Field::m_name => {
1115 #[cfg(
1116 any(feature = "strict", feature = "ignore_duplicates")
1117 )]
1118 if _serde::__private::Option::is_some(&m_name) {
1119 #[cfg(feature = "ignore_duplicates")]
1120 {
1121 __A::skip_value(&mut __map)?;
1122 continue;
1123 }
1124 #[cfg(feature = "strict")]
1125 return _serde::__private::Err(
1126 <__A::Error as _serde::de::Error>::duplicate_field("name"),
1127 );
1128 }
1129 m_name = _serde::__private::Some(
1130 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1131 _serde::__private::Ok(__val) => __val,
1132 _serde::__private::Err(__err) => {
1133 return _serde::__private::Err(__err);
1134 }
1135 },
1136 );
1137 }
1138 __Field::m_enable => {
1139 #[cfg(
1140 any(feature = "strict", feature = "ignore_duplicates")
1141 )]
1142 if _serde::__private::Option::is_some(&m_enable) {
1143 #[cfg(feature = "ignore_duplicates")]
1144 {
1145 __A::skip_value(&mut __map)?;
1146 continue;
1147 }
1148 #[cfg(feature = "strict")]
1149 return _serde::__private::Err(
1150 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
1151 );
1152 }
1153 m_enable = _serde::__private::Some(
1154 match __A::next_value::<bool>(&mut __map) {
1155 _serde::__private::Ok(__val) => __val,
1156 _serde::__private::Err(__err) => {
1157 return _serde::__private::Err(__err);
1158 }
1159 },
1160 );
1161 }
1162 __Field::m_lookAtTarget => {
1163 #[cfg(
1164 any(feature = "strict", feature = "ignore_duplicates")
1165 )]
1166 if _serde::__private::Option::is_some(&m_lookAtTarget) {
1167 #[cfg(feature = "ignore_duplicates")]
1168 {
1169 __A::skip_value(&mut __map)?;
1170 continue;
1171 }
1172 #[cfg(feature = "strict")]
1173 return _serde::__private::Err(
1174 <__A::Error as _serde::de::Error>::duplicate_field(
1175 "lookAtTarget",
1176 ),
1177 );
1178 }
1179 m_lookAtTarget = _serde::__private::Some(
1180 match __A::next_value::<bool>(&mut __map) {
1181 _serde::__private::Ok(__val) => __val,
1182 _serde::__private::Err(__err) => {
1183 return _serde::__private::Err(__err);
1184 }
1185 },
1186 );
1187 }
1188 __Field::m_bones => {
1189 #[cfg(
1190 any(feature = "strict", feature = "ignore_duplicates")
1191 )]
1192 if _serde::__private::Option::is_some(&m_bones) {
1193 #[cfg(feature = "ignore_duplicates")]
1194 {
1195 __A::skip_value(&mut __map)?;
1196 continue;
1197 }
1198 #[cfg(feature = "strict")]
1199 return _serde::__private::Err(
1200 <__A::Error as _serde::de::Error>::duplicate_field("bones"),
1201 );
1202 }
1203 m_bones = _serde::__private::Some(
1204 match __A::next_value::<
1205 Vec<BSLookAtModifierBoneData>,
1206 >(&mut __map) {
1207 _serde::__private::Ok(__val) => __val,
1208 _serde::__private::Err(__err) => {
1209 return _serde::__private::Err(__err);
1210 }
1211 },
1212 );
1213 }
1214 __Field::m_eyeBones => {
1215 #[cfg(
1216 any(feature = "strict", feature = "ignore_duplicates")
1217 )]
1218 if _serde::__private::Option::is_some(&m_eyeBones) {
1219 #[cfg(feature = "ignore_duplicates")]
1220 {
1221 __A::skip_value(&mut __map)?;
1222 continue;
1223 }
1224 #[cfg(feature = "strict")]
1225 return _serde::__private::Err(
1226 <__A::Error as _serde::de::Error>::duplicate_field(
1227 "eyeBones",
1228 ),
1229 );
1230 }
1231 m_eyeBones = _serde::__private::Some(
1232 match __A::next_value::<
1233 Vec<BSLookAtModifierBoneData>,
1234 >(&mut __map) {
1235 _serde::__private::Ok(__val) => __val,
1236 _serde::__private::Err(__err) => {
1237 return _serde::__private::Err(__err);
1238 }
1239 },
1240 );
1241 }
1242 __Field::m_limitAngleDegrees => {
1243 #[cfg(
1244 any(feature = "strict", feature = "ignore_duplicates")
1245 )]
1246 if _serde::__private::Option::is_some(
1247 &m_limitAngleDegrees,
1248 ) {
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 "limitAngleDegrees",
1258 ),
1259 );
1260 }
1261 m_limitAngleDegrees = _serde::__private::Some(
1262 match __A::next_value::<f32>(&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_limitAngleThresholdDegrees => {
1271 #[cfg(
1272 any(feature = "strict", feature = "ignore_duplicates")
1273 )]
1274 if _serde::__private::Option::is_some(
1275 &m_limitAngleThresholdDegrees,
1276 ) {
1277 #[cfg(feature = "ignore_duplicates")]
1278 {
1279 __A::skip_value(&mut __map)?;
1280 continue;
1281 }
1282 #[cfg(feature = "strict")]
1283 return _serde::__private::Err(
1284 <__A::Error as _serde::de::Error>::duplicate_field(
1285 "limitAngleThresholdDegrees",
1286 ),
1287 );
1288 }
1289 m_limitAngleThresholdDegrees = _serde::__private::Some(
1290 match __A::next_value::<f32>(&mut __map) {
1291 _serde::__private::Ok(__val) => __val,
1292 _serde::__private::Err(__err) => {
1293 return _serde::__private::Err(__err);
1294 }
1295 },
1296 );
1297 }
1298 __Field::m_continueLookOutsideOfLimit => {
1299 #[cfg(
1300 any(feature = "strict", feature = "ignore_duplicates")
1301 )]
1302 if _serde::__private::Option::is_some(
1303 &m_continueLookOutsideOfLimit,
1304 ) {
1305 #[cfg(feature = "ignore_duplicates")]
1306 {
1307 __A::skip_value(&mut __map)?;
1308 continue;
1309 }
1310 #[cfg(feature = "strict")]
1311 return _serde::__private::Err(
1312 <__A::Error as _serde::de::Error>::duplicate_field(
1313 "continueLookOutsideOfLimit",
1314 ),
1315 );
1316 }
1317 m_continueLookOutsideOfLimit = _serde::__private::Some(
1318 match __A::next_value::<bool>(&mut __map) {
1319 _serde::__private::Ok(__val) => __val,
1320 _serde::__private::Err(__err) => {
1321 return _serde::__private::Err(__err);
1322 }
1323 },
1324 );
1325 }
1326 __Field::m_onGain => {
1327 #[cfg(
1328 any(feature = "strict", feature = "ignore_duplicates")
1329 )]
1330 if _serde::__private::Option::is_some(&m_onGain) {
1331 #[cfg(feature = "ignore_duplicates")]
1332 {
1333 __A::skip_value(&mut __map)?;
1334 continue;
1335 }
1336 #[cfg(feature = "strict")]
1337 return _serde::__private::Err(
1338 <__A::Error as _serde::de::Error>::duplicate_field("onGain"),
1339 );
1340 }
1341 m_onGain = _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_offGain => {
1351 #[cfg(
1352 any(feature = "strict", feature = "ignore_duplicates")
1353 )]
1354 if _serde::__private::Option::is_some(&m_offGain) {
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 "offGain",
1364 ),
1365 );
1366 }
1367 m_offGain = _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_useBoneGains => {
1377 #[cfg(
1378 any(feature = "strict", feature = "ignore_duplicates")
1379 )]
1380 if _serde::__private::Option::is_some(&m_useBoneGains) {
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 "useBoneGains",
1390 ),
1391 );
1392 }
1393 m_useBoneGains = _serde::__private::Some(
1394 match __A::next_value::<bool>(&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_targetLocation => {
1403 #[cfg(
1404 any(feature = "strict", feature = "ignore_duplicates")
1405 )]
1406 if _serde::__private::Option::is_some(&m_targetLocation) {
1407 #[cfg(feature = "ignore_duplicates")]
1408 {
1409 __A::skip_value(&mut __map)?;
1410 continue;
1411 }
1412 #[cfg(feature = "strict")]
1413 return _serde::__private::Err(
1414 <__A::Error as _serde::de::Error>::duplicate_field(
1415 "targetLocation",
1416 ),
1417 );
1418 }
1419 m_targetLocation = _serde::__private::Some(
1420 match __A::next_value::<Vector4>(&mut __map) {
1421 _serde::__private::Ok(__val) => __val,
1422 _serde::__private::Err(__err) => {
1423 return _serde::__private::Err(__err);
1424 }
1425 },
1426 );
1427 }
1428 __Field::m_targetOutsideLimits => {
1429 #[cfg(
1430 any(feature = "strict", feature = "ignore_duplicates")
1431 )]
1432 if _serde::__private::Option::is_some(
1433 &m_targetOutsideLimits,
1434 ) {
1435 #[cfg(feature = "ignore_duplicates")]
1436 {
1437 __A::skip_value(&mut __map)?;
1438 continue;
1439 }
1440 #[cfg(feature = "strict")]
1441 return _serde::__private::Err(
1442 <__A::Error as _serde::de::Error>::duplicate_field(
1443 "targetOutsideLimits",
1444 ),
1445 );
1446 }
1447 m_targetOutsideLimits = _serde::__private::Some(
1448 match __A::next_value::<bool>(&mut __map) {
1449 _serde::__private::Ok(__val) => __val,
1450 _serde::__private::Err(__err) => {
1451 return _serde::__private::Err(__err);
1452 }
1453 },
1454 );
1455 }
1456 __Field::m_targetOutOfLimitEvent => {
1457 #[cfg(
1458 any(feature = "strict", feature = "ignore_duplicates")
1459 )]
1460 if _serde::__private::Option::is_some(
1461 &m_targetOutOfLimitEvent,
1462 ) {
1463 #[cfg(feature = "ignore_duplicates")]
1464 {
1465 __A::skip_value(&mut __map)?;
1466 continue;
1467 }
1468 #[cfg(feature = "strict")]
1469 return _serde::__private::Err(
1470 <__A::Error as _serde::de::Error>::duplicate_field(
1471 "targetOutOfLimitEvent",
1472 ),
1473 );
1474 }
1475 m_targetOutOfLimitEvent = _serde::__private::Some(
1476 match __A::next_value::<hkbEventProperty>(&mut __map) {
1477 _serde::__private::Ok(__val) => __val,
1478 _serde::__private::Err(__err) => {
1479 return _serde::__private::Err(__err);
1480 }
1481 },
1482 );
1483 }
1484 __Field::m_lookAtCamera => {
1485 #[cfg(
1486 any(feature = "strict", feature = "ignore_duplicates")
1487 )]
1488 if _serde::__private::Option::is_some(&m_lookAtCamera) {
1489 #[cfg(feature = "ignore_duplicates")]
1490 {
1491 __A::skip_value(&mut __map)?;
1492 continue;
1493 }
1494 #[cfg(feature = "strict")]
1495 return _serde::__private::Err(
1496 <__A::Error as _serde::de::Error>::duplicate_field(
1497 "lookAtCamera",
1498 ),
1499 );
1500 }
1501 m_lookAtCamera = _serde::__private::Some(
1502 match __A::next_value::<bool>(&mut __map) {
1503 _serde::__private::Ok(__val) => __val,
1504 _serde::__private::Err(__err) => {
1505 return _serde::__private::Err(__err);
1506 }
1507 },
1508 );
1509 }
1510 __Field::m_lookAtCameraX => {
1511 #[cfg(
1512 any(feature = "strict", feature = "ignore_duplicates")
1513 )]
1514 if _serde::__private::Option::is_some(&m_lookAtCameraX) {
1515 #[cfg(feature = "ignore_duplicates")]
1516 {
1517 __A::skip_value(&mut __map)?;
1518 continue;
1519 }
1520 #[cfg(feature = "strict")]
1521 return _serde::__private::Err(
1522 <__A::Error as _serde::de::Error>::duplicate_field(
1523 "lookAtCameraX",
1524 ),
1525 );
1526 }
1527 m_lookAtCameraX = _serde::__private::Some(
1528 match __A::next_value::<f32>(&mut __map) {
1529 _serde::__private::Ok(__val) => __val,
1530 _serde::__private::Err(__err) => {
1531 return _serde::__private::Err(__err);
1532 }
1533 },
1534 );
1535 }
1536 __Field::m_lookAtCameraY => {
1537 #[cfg(
1538 any(feature = "strict", feature = "ignore_duplicates")
1539 )]
1540 if _serde::__private::Option::is_some(&m_lookAtCameraY) {
1541 #[cfg(feature = "ignore_duplicates")]
1542 {
1543 __A::skip_value(&mut __map)?;
1544 continue;
1545 }
1546 #[cfg(feature = "strict")]
1547 return _serde::__private::Err(
1548 <__A::Error as _serde::de::Error>::duplicate_field(
1549 "lookAtCameraY",
1550 ),
1551 );
1552 }
1553 m_lookAtCameraY = _serde::__private::Some(
1554 match __A::next_value::<f32>(&mut __map) {
1555 _serde::__private::Ok(__val) => __val,
1556 _serde::__private::Err(__err) => {
1557 return _serde::__private::Err(__err);
1558 }
1559 },
1560 );
1561 }
1562 __Field::m_lookAtCameraZ => {
1563 #[cfg(
1564 any(feature = "strict", feature = "ignore_duplicates")
1565 )]
1566 if _serde::__private::Option::is_some(&m_lookAtCameraZ) {
1567 #[cfg(feature = "ignore_duplicates")]
1568 {
1569 __A::skip_value(&mut __map)?;
1570 continue;
1571 }
1572 #[cfg(feature = "strict")]
1573 return _serde::__private::Err(
1574 <__A::Error as _serde::de::Error>::duplicate_field(
1575 "lookAtCameraZ",
1576 ),
1577 );
1578 }
1579 m_lookAtCameraZ = _serde::__private::Some(
1580 match __A::next_value::<f32>(&mut __map) {
1581 _serde::__private::Ok(__val) => __val,
1582 _serde::__private::Err(__err) => {
1583 return _serde::__private::Err(__err);
1584 }
1585 },
1586 );
1587 }
1588 _ => __A::skip_value(&mut __map)?,
1589 }
1590 }
1591 let m_variableBindingSet = match m_variableBindingSet {
1592 _serde::__private::Some(__field) => __field,
1593 _serde::__private::None => {
1594 #[cfg(feature = "strict")]
1595 return _serde::__private::Err(
1596 <__A::Error as _serde::de::Error>::missing_field(
1597 "variableBindingSet",
1598 ),
1599 );
1600 #[cfg(not(feature = "strict"))] Default::default()
1601 }
1602 };
1603 let m_userData = match m_userData {
1604 _serde::__private::Some(__field) => __field,
1605 _serde::__private::None => {
1606 #[cfg(feature = "strict")]
1607 return _serde::__private::Err(
1608 <__A::Error as _serde::de::Error>::missing_field("userData"),
1609 );
1610 #[cfg(not(feature = "strict"))] Default::default()
1611 }
1612 };
1613 let m_name = match m_name {
1614 _serde::__private::Some(__field) => __field,
1615 _serde::__private::None => {
1616 #[cfg(feature = "strict")]
1617 return _serde::__private::Err(
1618 <__A::Error as _serde::de::Error>::missing_field("name"),
1619 );
1620 #[cfg(not(feature = "strict"))] Default::default()
1621 }
1622 };
1623 let m_enable = match m_enable {
1624 _serde::__private::Some(__field) => __field,
1625 _serde::__private::None => {
1626 #[cfg(feature = "strict")]
1627 return _serde::__private::Err(
1628 <__A::Error as _serde::de::Error>::missing_field("enable"),
1629 );
1630 #[cfg(not(feature = "strict"))] Default::default()
1631 }
1632 };
1633 let m_lookAtTarget = match m_lookAtTarget {
1634 _serde::__private::Some(__field) => __field,
1635 _serde::__private::None => {
1636 #[cfg(feature = "strict")]
1637 return _serde::__private::Err(
1638 <__A::Error as _serde::de::Error>::missing_field(
1639 "lookAtTarget",
1640 ),
1641 );
1642 #[cfg(not(feature = "strict"))] Default::default()
1643 }
1644 };
1645 let m_bones = match m_bones {
1646 _serde::__private::Some(__field) => __field,
1647 _serde::__private::None => {
1648 #[cfg(feature = "strict")]
1649 return _serde::__private::Err(
1650 <__A::Error as _serde::de::Error>::missing_field("bones"),
1651 );
1652 #[cfg(not(feature = "strict"))] Default::default()
1653 }
1654 };
1655 let m_eyeBones = match m_eyeBones {
1656 _serde::__private::Some(__field) => __field,
1657 _serde::__private::None => {
1658 #[cfg(feature = "strict")]
1659 return _serde::__private::Err(
1660 <__A::Error as _serde::de::Error>::missing_field("eyeBones"),
1661 );
1662 #[cfg(not(feature = "strict"))] Default::default()
1663 }
1664 };
1665 let m_limitAngleDegrees = match m_limitAngleDegrees {
1666 _serde::__private::Some(__field) => __field,
1667 _serde::__private::None => {
1668 #[cfg(feature = "strict")]
1669 return _serde::__private::Err(
1670 <__A::Error as _serde::de::Error>::missing_field(
1671 "limitAngleDegrees",
1672 ),
1673 );
1674 #[cfg(not(feature = "strict"))] Default::default()
1675 }
1676 };
1677 let m_limitAngleThresholdDegrees = match m_limitAngleThresholdDegrees {
1678 _serde::__private::Some(__field) => __field,
1679 _serde::__private::None => {
1680 #[cfg(feature = "strict")]
1681 return _serde::__private::Err(
1682 <__A::Error as _serde::de::Error>::missing_field(
1683 "limitAngleThresholdDegrees",
1684 ),
1685 );
1686 #[cfg(not(feature = "strict"))] Default::default()
1687 }
1688 };
1689 let m_continueLookOutsideOfLimit = match m_continueLookOutsideOfLimit {
1690 _serde::__private::Some(__field) => __field,
1691 _serde::__private::None => {
1692 #[cfg(feature = "strict")]
1693 return _serde::__private::Err(
1694 <__A::Error as _serde::de::Error>::missing_field(
1695 "continueLookOutsideOfLimit",
1696 ),
1697 );
1698 #[cfg(not(feature = "strict"))] Default::default()
1699 }
1700 };
1701 let m_onGain = match m_onGain {
1702 _serde::__private::Some(__field) => __field,
1703 _serde::__private::None => {
1704 #[cfg(feature = "strict")]
1705 return _serde::__private::Err(
1706 <__A::Error as _serde::de::Error>::missing_field("onGain"),
1707 );
1708 #[cfg(not(feature = "strict"))] Default::default()
1709 }
1710 };
1711 let m_offGain = match m_offGain {
1712 _serde::__private::Some(__field) => __field,
1713 _serde::__private::None => {
1714 #[cfg(feature = "strict")]
1715 return _serde::__private::Err(
1716 <__A::Error as _serde::de::Error>::missing_field("offGain"),
1717 );
1718 #[cfg(not(feature = "strict"))] Default::default()
1719 }
1720 };
1721 let m_useBoneGains = match m_useBoneGains {
1722 _serde::__private::Some(__field) => __field,
1723 _serde::__private::None => {
1724 #[cfg(feature = "strict")]
1725 return _serde::__private::Err(
1726 <__A::Error as _serde::de::Error>::missing_field(
1727 "useBoneGains",
1728 ),
1729 );
1730 #[cfg(not(feature = "strict"))] Default::default()
1731 }
1732 };
1733 let m_targetLocation = match m_targetLocation {
1734 _serde::__private::Some(__field) => __field,
1735 _serde::__private::None => {
1736 #[cfg(feature = "strict")]
1737 return _serde::__private::Err(
1738 <__A::Error as _serde::de::Error>::missing_field(
1739 "targetLocation",
1740 ),
1741 );
1742 #[cfg(not(feature = "strict"))] Default::default()
1743 }
1744 };
1745 let m_targetOutsideLimits = match m_targetOutsideLimits {
1746 _serde::__private::Some(__field) => __field,
1747 _serde::__private::None => {
1748 #[cfg(feature = "strict")]
1749 return _serde::__private::Err(
1750 <__A::Error as _serde::de::Error>::missing_field(
1751 "targetOutsideLimits",
1752 ),
1753 );
1754 #[cfg(not(feature = "strict"))] Default::default()
1755 }
1756 };
1757 let m_targetOutOfLimitEvent = match m_targetOutOfLimitEvent {
1758 _serde::__private::Some(__field) => __field,
1759 _serde::__private::None => {
1760 #[cfg(feature = "strict")]
1761 return _serde::__private::Err(
1762 <__A::Error as _serde::de::Error>::missing_field(
1763 "targetOutOfLimitEvent",
1764 ),
1765 );
1766 #[cfg(not(feature = "strict"))] Default::default()
1767 }
1768 };
1769 let m_lookAtCamera = match m_lookAtCamera {
1770 _serde::__private::Some(__field) => __field,
1771 _serde::__private::None => {
1772 #[cfg(feature = "strict")]
1773 return _serde::__private::Err(
1774 <__A::Error as _serde::de::Error>::missing_field(
1775 "lookAtCamera",
1776 ),
1777 );
1778 #[cfg(not(feature = "strict"))] Default::default()
1779 }
1780 };
1781 let m_lookAtCameraX = match m_lookAtCameraX {
1782 _serde::__private::Some(__field) => __field,
1783 _serde::__private::None => {
1784 #[cfg(feature = "strict")]
1785 return _serde::__private::Err(
1786 <__A::Error as _serde::de::Error>::missing_field(
1787 "lookAtCameraX",
1788 ),
1789 );
1790 #[cfg(not(feature = "strict"))] Default::default()
1791 }
1792 };
1793 let m_lookAtCameraY = match m_lookAtCameraY {
1794 _serde::__private::Some(__field) => __field,
1795 _serde::__private::None => {
1796 #[cfg(feature = "strict")]
1797 return _serde::__private::Err(
1798 <__A::Error as _serde::de::Error>::missing_field(
1799 "lookAtCameraY",
1800 ),
1801 );
1802 #[cfg(not(feature = "strict"))] Default::default()
1803 }
1804 };
1805 let m_lookAtCameraZ = match m_lookAtCameraZ {
1806 _serde::__private::Some(__field) => __field,
1807 _serde::__private::None => {
1808 #[cfg(feature = "strict")]
1809 return _serde::__private::Err(
1810 <__A::Error as _serde::de::Error>::missing_field(
1811 "lookAtCameraZ",
1812 ),
1813 );
1814 #[cfg(not(feature = "strict"))] Default::default()
1815 }
1816 };
1817 let __ptr = None;
1818 let parent = hkBaseObject { __ptr };
1819 let parent = hkReferencedObject {
1820 __ptr,
1821 parent,
1822 ..Default::default()
1823 };
1824 let parent = hkbBindable {
1825 __ptr,
1826 parent,
1827 m_variableBindingSet,
1828 ..Default::default()
1829 };
1830 let parent = hkbNode {
1831 __ptr,
1832 parent,
1833 m_userData,
1834 m_name,
1835 ..Default::default()
1836 };
1837 let parent = hkbModifier {
1838 __ptr,
1839 parent,
1840 m_enable,
1841 ..Default::default()
1842 };
1843 let __ptr = __A::class_ptr(&mut __map);
1844 _serde::__private::Ok(BSLookAtModifier {
1845 __ptr,
1846 parent,
1847 m_lookAtTarget,
1848 m_bones,
1849 m_eyeBones,
1850 m_limitAngleDegrees,
1851 m_limitAngleThresholdDegrees,
1852 m_continueLookOutsideOfLimit,
1853 m_onGain,
1854 m_offGain,
1855 m_useBoneGains,
1856 m_targetLocation,
1857 m_targetOutsideLimits,
1858 m_targetOutOfLimitEvent,
1859 m_lookAtCamera,
1860 m_lookAtCameraX,
1861 m_lookAtCameraY,
1862 m_lookAtCameraZ,
1863 ..Default::default()
1864 })
1865 }
1866 }
1867 const FIELDS: &[&str] = &[
1868 "lookAtTarget",
1869 "bones",
1870 "eyeBones",
1871 "limitAngleDegrees",
1872 "limitAngleThresholdDegrees",
1873 "continueLookOutsideOfLimit",
1874 "onGain",
1875 "offGain",
1876 "useBoneGains",
1877 "targetLocation",
1878 "targetOutsideLimits",
1879 "targetOutOfLimitEvent",
1880 "lookAtCamera",
1881 "lookAtCameraX",
1882 "lookAtCameraY",
1883 "lookAtCameraZ",
1884 "timeStep",
1885 "ballBonesValid",
1886 "pSkeletonMemory",
1887 ];
1888 _serde::Deserializer::deserialize_struct(
1889 deserializer,
1890 "BSLookAtModifier",
1891 FIELDS,
1892 __BSLookAtModifierVisitor {
1893 marker: _serde::__private::PhantomData::<BSLookAtModifier>,
1894 lifetime: _serde::__private::PhantomData,
1895 },
1896 )
1897 }
1898 }
1899};