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