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 BSComputeAddBoneAnimModifier<'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 = "boneIndex"))]
36 #[cfg_attr(feature = "serde", serde(rename = "boneIndex"))]
37 pub m_boneIndex: i16,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "translationLSOut"))]
43 #[cfg_attr(feature = "serde", serde(rename = "translationLSOut"))]
44 pub m_translationLSOut: Vector4,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "rotationLSOut"))]
50 #[cfg_attr(feature = "serde", serde(rename = "rotationLSOut"))]
51 pub m_rotationLSOut: Quaternion,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "scaleLSOut"))]
57 #[cfg_attr(feature = "serde", serde(rename = "scaleLSOut"))]
58 pub m_scaleLSOut: Vector4,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "pSkeletonMemory"))]
65 #[cfg_attr(feature = "serde", serde(rename = "pSkeletonMemory"))]
66 pub m_pSkeletonMemory: Pointer,
67}
68const _: () = {
69 use havok_serde as _serde;
70 impl<'a> _serde::HavokClass for BSComputeAddBoneAnimModifier<'a> {
71 #[inline]
72 fn name(&self) -> &'static str {
73 "BSComputeAddBoneAnimModifier"
74 }
75 #[inline]
76 fn signature(&self) -> _serde::__private::Signature {
77 _serde::__private::Signature::new(0xa67f8c46)
78 }
79 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
80 fn deps_indexes(&self) -> Vec<usize> {
81 let mut v = Vec::new();
82 v.push(self.parent.parent.parent.m_variableBindingSet.get());
83 v.push(self.m_pSkeletonMemory.get());
84 v
85 }
86 }
87 impl<'a> _serde::Serialize for BSComputeAddBoneAnimModifier<'a> {
88 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
89 where
90 S: _serde::ser::Serializer,
91 {
92 let class_meta = self
93 .__ptr
94 .map(|name| (name, _serde::__private::Signature::new(0xa67f8c46)));
95 let mut serializer = __serializer
96 .serialize_struct(
97 "BSComputeAddBoneAnimModifier",
98 class_meta,
99 (112u64, 160u64),
100 )?;
101 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
102 serializer
103 .skip_field(
104 "memSizeAndFlags",
105 &self.parent.parent.parent.parent.m_memSizeAndFlags,
106 )?;
107 serializer
108 .skip_field(
109 "referenceCount",
110 &self.parent.parent.parent.parent.m_referenceCount,
111 )?;
112 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
113 serializer
114 .serialize_field(
115 "variableBindingSet",
116 &self.parent.parent.parent.m_variableBindingSet,
117 )?;
118 serializer
119 .skip_array_field(
120 "cachedBindables",
121 &self.parent.parent.parent.m_cachedBindables,
122 TypeSize::NonPtr,
123 )?;
124 serializer
125 .skip_field(
126 "areBindablesCached",
127 &self.parent.parent.parent.m_areBindablesCached,
128 )?;
129 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
130 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
131 serializer.serialize_field("name", &self.parent.parent.m_name)?;
132 serializer.skip_field("id", &self.parent.parent.m_id)?;
133 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
134 serializer
135 .skip_fixed_array_field(
136 "padNode",
137 self.parent.parent.m_padNode.as_slice(),
138 TypeSize::NonPtr,
139 )?;
140 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
141 serializer.serialize_field("enable", &self.parent.m_enable)?;
142 serializer
143 .skip_fixed_array_field(
144 "padModifier",
145 self.parent.m_padModifier.as_slice(),
146 TypeSize::NonPtr,
147 )?;
148 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
149 serializer.serialize_field("boneIndex", &self.m_boneIndex)?;
150 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 14usize].as_slice())?;
151 serializer.serialize_field("translationLSOut", &self.m_translationLSOut)?;
152 serializer.serialize_field("rotationLSOut", &self.m_rotationLSOut)?;
153 serializer.serialize_field("scaleLSOut", &self.m_scaleLSOut)?;
154 serializer.skip_field("pSkeletonMemory", &self.m_pSkeletonMemory)?;
155 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 8usize].as_slice())?;
156 serializer.end()
157 }
158 }
159};
160#[doc(hidden)]
161#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
162const _: () = {
163 use havok_serde as _serde;
164 #[automatically_derived]
165 impl<'de> _serde::Deserialize<'de> for BSComputeAddBoneAnimModifier<'de> {
166 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
167 where
168 __D: _serde::Deserializer<'de>,
169 {
170 #[allow(non_camel_case_types)]
171 enum __Field {
172 m_variableBindingSet,
173 m_userData,
174 m_name,
175 m_enable,
176 m_boneIndex,
177 m_translationLSOut,
178 m_rotationLSOut,
179 m_scaleLSOut,
180 __ignore,
181 }
182 struct __FieldVisitor;
183 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
184 type Value = __Field;
185 fn expecting(
186 &self,
187 __formatter: &mut core::fmt::Formatter,
188 ) -> core::fmt::Result {
189 core::fmt::Formatter::write_str(__formatter, "field identifier")
190 }
191 #[allow(clippy::match_single_binding)]
193 #[allow(clippy::reversed_empty_ranges)]
194 #[allow(clippy::single_match)]
195 fn visit_key<__E>(
196 self,
197 __value: &str,
198 ) -> core::result::Result<Self::Value, __E>
199 where
200 __E: _serde::de::Error,
201 {
202 match __value {
203 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
204 "userData" => Ok(__Field::m_userData),
205 "name" => Ok(__Field::m_name),
206 "enable" => Ok(__Field::m_enable),
207 "boneIndex" => Ok(__Field::m_boneIndex),
208 "translationLSOut" => Ok(__Field::m_translationLSOut),
209 "rotationLSOut" => Ok(__Field::m_rotationLSOut),
210 "scaleLSOut" => Ok(__Field::m_scaleLSOut),
211 _ => Ok(__Field::__ignore),
212 }
213 }
214 }
215 impl<'de> _serde::Deserialize<'de> for __Field {
216 #[inline]
217 fn deserialize<__D>(
218 __deserializer: __D,
219 ) -> core::result::Result<Self, __D::Error>
220 where
221 __D: _serde::Deserializer<'de>,
222 {
223 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
224 }
225 }
226 struct __BSComputeAddBoneAnimModifierVisitor<'de> {
227 marker: _serde::__private::PhantomData<
228 BSComputeAddBoneAnimModifier<'de>,
229 >,
230 lifetime: _serde::__private::PhantomData<&'de ()>,
231 }
232 #[allow(clippy::match_single_binding)]
233 #[allow(clippy::reversed_empty_ranges)]
234 #[allow(clippy::single_match)]
235 impl<'de> _serde::de::Visitor<'de>
236 for __BSComputeAddBoneAnimModifierVisitor<'de> {
237 type Value = BSComputeAddBoneAnimModifier<'de>;
238 fn expecting(
239 &self,
240 __formatter: &mut core::fmt::Formatter,
241 ) -> core::fmt::Result {
242 core::fmt::Formatter::write_str(
243 __formatter,
244 "struct BSComputeAddBoneAnimModifier",
245 )
246 }
247 fn visit_struct_for_bytes<__A>(
248 self,
249 mut __map: __A,
250 ) -> _serde::__private::Result<Self::Value, __A::Error>
251 where
252 __A: _serde::de::MapAccess<'de>,
253 {
254 let __ptr = __A::class_ptr(&mut __map);
255 let parent = __A::parent_value(&mut __map)?;
256 let mut m_boneIndex: _serde::__private::Option<i16> = _serde::__private::None;
257 let mut m_translationLSOut: _serde::__private::Option<Vector4> = _serde::__private::None;
258 let mut m_rotationLSOut: _serde::__private::Option<Quaternion> = _serde::__private::None;
259 let mut m_scaleLSOut: _serde::__private::Option<Vector4> = _serde::__private::None;
260 let mut m_pSkeletonMemory: _serde::__private::Option<Pointer> = _serde::__private::None;
261 for i in 0..5usize {
262 match i {
263 0usize => {
264 if _serde::__private::Option::is_some(&m_boneIndex) {
265 return _serde::__private::Err(
266 <__A::Error as _serde::de::Error>::duplicate_field(
267 "boneIndex",
268 ),
269 );
270 }
271 m_boneIndex = _serde::__private::Some(
272 match __A::next_value::<i16>(&mut __map) {
273 _serde::__private::Ok(__val) => __val,
274 _serde::__private::Err(__err) => {
275 return _serde::__private::Err(__err);
276 }
277 },
278 );
279 }
280 1usize => {
281 if _serde::__private::Option::is_some(&m_translationLSOut) {
282 return _serde::__private::Err(
283 <__A::Error as _serde::de::Error>::duplicate_field(
284 "translationLSOut",
285 ),
286 );
287 }
288 __A::pad(&mut __map, 2usize, 14usize)?;
289 m_translationLSOut = _serde::__private::Some(
290 match __A::next_value::<Vector4>(&mut __map) {
291 _serde::__private::Ok(__val) => __val,
292 _serde::__private::Err(__err) => {
293 return _serde::__private::Err(__err);
294 }
295 },
296 );
297 }
298 2usize => {
299 if _serde::__private::Option::is_some(&m_rotationLSOut) {
300 return _serde::__private::Err(
301 <__A::Error as _serde::de::Error>::duplicate_field(
302 "rotationLSOut",
303 ),
304 );
305 }
306 m_rotationLSOut = _serde::__private::Some(
307 match __A::next_value::<Quaternion>(&mut __map) {
308 _serde::__private::Ok(__val) => __val,
309 _serde::__private::Err(__err) => {
310 return _serde::__private::Err(__err);
311 }
312 },
313 );
314 }
315 3usize => {
316 if _serde::__private::Option::is_some(&m_scaleLSOut) {
317 return _serde::__private::Err(
318 <__A::Error as _serde::de::Error>::duplicate_field(
319 "scaleLSOut",
320 ),
321 );
322 }
323 m_scaleLSOut = _serde::__private::Some(
324 match __A::next_value::<Vector4>(&mut __map) {
325 _serde::__private::Ok(__val) => __val,
326 _serde::__private::Err(__err) => {
327 return _serde::__private::Err(__err);
328 }
329 },
330 );
331 }
332 4usize => {
333 if _serde::__private::Option::is_some(&m_pSkeletonMemory) {
334 return _serde::__private::Err(
335 <__A::Error as _serde::de::Error>::duplicate_field(
336 "pSkeletonMemory",
337 ),
338 );
339 }
340 m_pSkeletonMemory = _serde::__private::Some(
341 match __A::next_value::<Pointer>(&mut __map) {
342 _serde::__private::Ok(__val) => __val,
343 _serde::__private::Err(__err) => {
344 return _serde::__private::Err(__err);
345 }
346 },
347 );
348 }
349 _ => {}
350 }
351 }
352 __A::pad(&mut __map, 12usize, 8usize)?;
353 let m_boneIndex = match m_boneIndex {
354 _serde::__private::Some(__field) => __field,
355 _serde::__private::None => {
356 return _serde::__private::Err(
357 <__A::Error as _serde::de::Error>::missing_field(
358 "boneIndex",
359 ),
360 );
361 }
362 };
363 let m_translationLSOut = match m_translationLSOut {
364 _serde::__private::Some(__field) => __field,
365 _serde::__private::None => {
366 return _serde::__private::Err(
367 <__A::Error as _serde::de::Error>::missing_field(
368 "translationLSOut",
369 ),
370 );
371 }
372 };
373 let m_rotationLSOut = match m_rotationLSOut {
374 _serde::__private::Some(__field) => __field,
375 _serde::__private::None => {
376 return _serde::__private::Err(
377 <__A::Error as _serde::de::Error>::missing_field(
378 "rotationLSOut",
379 ),
380 );
381 }
382 };
383 let m_scaleLSOut = match m_scaleLSOut {
384 _serde::__private::Some(__field) => __field,
385 _serde::__private::None => {
386 return _serde::__private::Err(
387 <__A::Error as _serde::de::Error>::missing_field(
388 "scaleLSOut",
389 ),
390 );
391 }
392 };
393 let m_pSkeletonMemory = match m_pSkeletonMemory {
394 _serde::__private::Some(__field) => __field,
395 _serde::__private::None => {
396 return _serde::__private::Err(
397 <__A::Error as _serde::de::Error>::missing_field(
398 "pSkeletonMemory",
399 ),
400 );
401 }
402 };
403 _serde::__private::Ok(BSComputeAddBoneAnimModifier {
404 __ptr,
405 parent,
406 m_boneIndex,
407 m_translationLSOut,
408 m_rotationLSOut,
409 m_scaleLSOut,
410 m_pSkeletonMemory,
411 })
412 }
413 #[allow(clippy::manual_unwrap_or_default)]
414 fn visit_struct<__A>(
415 self,
416 mut __map: __A,
417 ) -> _serde::__private::Result<Self::Value, __A::Error>
418 where
419 __A: _serde::de::MapAccess<'de>,
420 {
421 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
422 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
423 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
424 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
425 let mut m_boneIndex: _serde::__private::Option<i16> = _serde::__private::None;
426 let mut m_translationLSOut: _serde::__private::Option<Vector4> = _serde::__private::None;
427 let mut m_rotationLSOut: _serde::__private::Option<Quaternion> = _serde::__private::None;
428 let mut m_scaleLSOut: _serde::__private::Option<Vector4> = _serde::__private::None;
429 while let _serde::__private::Some(__key) = {
430 __A::next_key::<__Field>(&mut __map)?
431 } {
432 match __key {
433 __Field::m_variableBindingSet => {
434 #[cfg(
435 any(feature = "strict", feature = "ignore_duplicates")
436 )]
437 if _serde::__private::Option::is_some(
438 &m_variableBindingSet,
439 ) {
440 #[cfg(feature = "ignore_duplicates")]
441 {
442 __A::skip_value(&mut __map)?;
443 continue;
444 }
445 #[cfg(feature = "strict")]
446 return _serde::__private::Err(
447 <__A::Error as _serde::de::Error>::duplicate_field(
448 "variableBindingSet",
449 ),
450 );
451 }
452 m_variableBindingSet = _serde::__private::Some(
453 match __A::next_value::<Pointer>(&mut __map) {
454 _serde::__private::Ok(__val) => __val,
455 _serde::__private::Err(__err) => {
456 return _serde::__private::Err(__err);
457 }
458 },
459 );
460 }
461 __Field::m_userData => {
462 #[cfg(
463 any(feature = "strict", feature = "ignore_duplicates")
464 )]
465 if _serde::__private::Option::is_some(&m_userData) {
466 #[cfg(feature = "ignore_duplicates")]
467 {
468 __A::skip_value(&mut __map)?;
469 continue;
470 }
471 #[cfg(feature = "strict")]
472 return _serde::__private::Err(
473 <__A::Error as _serde::de::Error>::duplicate_field(
474 "userData",
475 ),
476 );
477 }
478 m_userData = _serde::__private::Some(
479 match __A::next_value::<Ulong>(&mut __map) {
480 _serde::__private::Ok(__val) => __val,
481 _serde::__private::Err(__err) => {
482 return _serde::__private::Err(__err);
483 }
484 },
485 );
486 }
487 __Field::m_name => {
488 #[cfg(
489 any(feature = "strict", feature = "ignore_duplicates")
490 )]
491 if _serde::__private::Option::is_some(&m_name) {
492 #[cfg(feature = "ignore_duplicates")]
493 {
494 __A::skip_value(&mut __map)?;
495 continue;
496 }
497 #[cfg(feature = "strict")]
498 return _serde::__private::Err(
499 <__A::Error as _serde::de::Error>::duplicate_field("name"),
500 );
501 }
502 m_name = _serde::__private::Some(
503 match __A::next_value::<StringPtr<'de>>(&mut __map) {
504 _serde::__private::Ok(__val) => __val,
505 _serde::__private::Err(__err) => {
506 return _serde::__private::Err(__err);
507 }
508 },
509 );
510 }
511 __Field::m_enable => {
512 #[cfg(
513 any(feature = "strict", feature = "ignore_duplicates")
514 )]
515 if _serde::__private::Option::is_some(&m_enable) {
516 #[cfg(feature = "ignore_duplicates")]
517 {
518 __A::skip_value(&mut __map)?;
519 continue;
520 }
521 #[cfg(feature = "strict")]
522 return _serde::__private::Err(
523 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
524 );
525 }
526 m_enable = _serde::__private::Some(
527 match __A::next_value::<bool>(&mut __map) {
528 _serde::__private::Ok(__val) => __val,
529 _serde::__private::Err(__err) => {
530 return _serde::__private::Err(__err);
531 }
532 },
533 );
534 }
535 __Field::m_boneIndex => {
536 #[cfg(
537 any(feature = "strict", feature = "ignore_duplicates")
538 )]
539 if _serde::__private::Option::is_some(&m_boneIndex) {
540 #[cfg(feature = "ignore_duplicates")]
541 {
542 __A::skip_value(&mut __map)?;
543 continue;
544 }
545 #[cfg(feature = "strict")]
546 return _serde::__private::Err(
547 <__A::Error as _serde::de::Error>::duplicate_field(
548 "boneIndex",
549 ),
550 );
551 }
552 m_boneIndex = _serde::__private::Some(
553 match __A::next_value::<i16>(&mut __map) {
554 _serde::__private::Ok(__val) => __val,
555 _serde::__private::Err(__err) => {
556 return _serde::__private::Err(__err);
557 }
558 },
559 );
560 }
561 __Field::m_translationLSOut => {
562 #[cfg(
563 any(feature = "strict", feature = "ignore_duplicates")
564 )]
565 if _serde::__private::Option::is_some(&m_translationLSOut) {
566 #[cfg(feature = "ignore_duplicates")]
567 {
568 __A::skip_value(&mut __map)?;
569 continue;
570 }
571 #[cfg(feature = "strict")]
572 return _serde::__private::Err(
573 <__A::Error as _serde::de::Error>::duplicate_field(
574 "translationLSOut",
575 ),
576 );
577 }
578 m_translationLSOut = _serde::__private::Some(
579 match __A::next_value::<Vector4>(&mut __map) {
580 _serde::__private::Ok(__val) => __val,
581 _serde::__private::Err(__err) => {
582 return _serde::__private::Err(__err);
583 }
584 },
585 );
586 }
587 __Field::m_rotationLSOut => {
588 #[cfg(
589 any(feature = "strict", feature = "ignore_duplicates")
590 )]
591 if _serde::__private::Option::is_some(&m_rotationLSOut) {
592 #[cfg(feature = "ignore_duplicates")]
593 {
594 __A::skip_value(&mut __map)?;
595 continue;
596 }
597 #[cfg(feature = "strict")]
598 return _serde::__private::Err(
599 <__A::Error as _serde::de::Error>::duplicate_field(
600 "rotationLSOut",
601 ),
602 );
603 }
604 m_rotationLSOut = _serde::__private::Some(
605 match __A::next_value::<Quaternion>(&mut __map) {
606 _serde::__private::Ok(__val) => __val,
607 _serde::__private::Err(__err) => {
608 return _serde::__private::Err(__err);
609 }
610 },
611 );
612 }
613 __Field::m_scaleLSOut => {
614 #[cfg(
615 any(feature = "strict", feature = "ignore_duplicates")
616 )]
617 if _serde::__private::Option::is_some(&m_scaleLSOut) {
618 #[cfg(feature = "ignore_duplicates")]
619 {
620 __A::skip_value(&mut __map)?;
621 continue;
622 }
623 #[cfg(feature = "strict")]
624 return _serde::__private::Err(
625 <__A::Error as _serde::de::Error>::duplicate_field(
626 "scaleLSOut",
627 ),
628 );
629 }
630 m_scaleLSOut = _serde::__private::Some(
631 match __A::next_value::<Vector4>(&mut __map) {
632 _serde::__private::Ok(__val) => __val,
633 _serde::__private::Err(__err) => {
634 return _serde::__private::Err(__err);
635 }
636 },
637 );
638 }
639 _ => __A::skip_value(&mut __map)?,
640 }
641 }
642 let m_variableBindingSet = match m_variableBindingSet {
643 _serde::__private::Some(__field) => __field,
644 _serde::__private::None => {
645 #[cfg(feature = "strict")]
646 return _serde::__private::Err(
647 <__A::Error as _serde::de::Error>::missing_field(
648 "variableBindingSet",
649 ),
650 );
651 #[cfg(not(feature = "strict"))] Default::default()
652 }
653 };
654 let m_userData = match m_userData {
655 _serde::__private::Some(__field) => __field,
656 _serde::__private::None => {
657 #[cfg(feature = "strict")]
658 return _serde::__private::Err(
659 <__A::Error as _serde::de::Error>::missing_field("userData"),
660 );
661 #[cfg(not(feature = "strict"))] Default::default()
662 }
663 };
664 let m_name = match m_name {
665 _serde::__private::Some(__field) => __field,
666 _serde::__private::None => {
667 #[cfg(feature = "strict")]
668 return _serde::__private::Err(
669 <__A::Error as _serde::de::Error>::missing_field("name"),
670 );
671 #[cfg(not(feature = "strict"))] Default::default()
672 }
673 };
674 let m_enable = match m_enable {
675 _serde::__private::Some(__field) => __field,
676 _serde::__private::None => {
677 #[cfg(feature = "strict")]
678 return _serde::__private::Err(
679 <__A::Error as _serde::de::Error>::missing_field("enable"),
680 );
681 #[cfg(not(feature = "strict"))] Default::default()
682 }
683 };
684 let m_boneIndex = match m_boneIndex {
685 _serde::__private::Some(__field) => __field,
686 _serde::__private::None => {
687 #[cfg(feature = "strict")]
688 return _serde::__private::Err(
689 <__A::Error as _serde::de::Error>::missing_field(
690 "boneIndex",
691 ),
692 );
693 #[cfg(not(feature = "strict"))] Default::default()
694 }
695 };
696 let m_translationLSOut = match m_translationLSOut {
697 _serde::__private::Some(__field) => __field,
698 _serde::__private::None => {
699 #[cfg(feature = "strict")]
700 return _serde::__private::Err(
701 <__A::Error as _serde::de::Error>::missing_field(
702 "translationLSOut",
703 ),
704 );
705 #[cfg(not(feature = "strict"))] Default::default()
706 }
707 };
708 let m_rotationLSOut = match m_rotationLSOut {
709 _serde::__private::Some(__field) => __field,
710 _serde::__private::None => {
711 #[cfg(feature = "strict")]
712 return _serde::__private::Err(
713 <__A::Error as _serde::de::Error>::missing_field(
714 "rotationLSOut",
715 ),
716 );
717 #[cfg(not(feature = "strict"))] Default::default()
718 }
719 };
720 let m_scaleLSOut = match m_scaleLSOut {
721 _serde::__private::Some(__field) => __field,
722 _serde::__private::None => {
723 #[cfg(feature = "strict")]
724 return _serde::__private::Err(
725 <__A::Error as _serde::de::Error>::missing_field(
726 "scaleLSOut",
727 ),
728 );
729 #[cfg(not(feature = "strict"))] Default::default()
730 }
731 };
732 let __ptr = None;
733 let parent = hkBaseObject { __ptr };
734 let parent = hkReferencedObject {
735 __ptr,
736 parent,
737 ..Default::default()
738 };
739 let parent = hkbBindable {
740 __ptr,
741 parent,
742 m_variableBindingSet,
743 ..Default::default()
744 };
745 let parent = hkbNode {
746 __ptr,
747 parent,
748 m_userData,
749 m_name,
750 ..Default::default()
751 };
752 let parent = hkbModifier {
753 __ptr,
754 parent,
755 m_enable,
756 ..Default::default()
757 };
758 let __ptr = __A::class_ptr(&mut __map);
759 _serde::__private::Ok(BSComputeAddBoneAnimModifier {
760 __ptr,
761 parent,
762 m_boneIndex,
763 m_translationLSOut,
764 m_rotationLSOut,
765 m_scaleLSOut,
766 ..Default::default()
767 })
768 }
769 }
770 const FIELDS: &[&str] = &[
771 "boneIndex",
772 "translationLSOut",
773 "rotationLSOut",
774 "scaleLSOut",
775 "pSkeletonMemory",
776 ];
777 _serde::Deserializer::deserialize_struct(
778 deserializer,
779 "BSComputeAddBoneAnimModifier",
780 FIELDS,
781 __BSComputeAddBoneAnimModifierVisitor {
782 marker: _serde::__private::PhantomData::<
783 BSComputeAddBoneAnimModifier,
784 >,
785 lifetime: _serde::__private::PhantomData,
786 },
787 )
788 }
789 }
790};