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