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