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