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