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 hkbBlenderGenerator<'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: hkbGenerator<'a>,
31 #[cfg_attr(
36 feature = "json_schema",
37 schemars(rename = "referencePoseWeightThreshold")
38 )]
39 #[cfg_attr(feature = "serde", serde(rename = "referencePoseWeightThreshold"))]
40 pub m_referencePoseWeightThreshold: f32,
41 #[cfg_attr(feature = "json_schema", schemars(rename = "blendParameter"))]
46 #[cfg_attr(feature = "serde", serde(rename = "blendParameter"))]
47 pub m_blendParameter: f32,
48 #[cfg_attr(feature = "json_schema", schemars(rename = "minCyclicBlendParameter"))]
53 #[cfg_attr(feature = "serde", serde(rename = "minCyclicBlendParameter"))]
54 pub m_minCyclicBlendParameter: f32,
55 #[cfg_attr(feature = "json_schema", schemars(rename = "maxCyclicBlendParameter"))]
60 #[cfg_attr(feature = "serde", serde(rename = "maxCyclicBlendParameter"))]
61 pub m_maxCyclicBlendParameter: f32,
62 #[cfg_attr(feature = "json_schema", schemars(rename = "indexOfSyncMasterChild"))]
67 #[cfg_attr(feature = "serde", serde(rename = "indexOfSyncMasterChild"))]
68 pub m_indexOfSyncMasterChild: i16,
69 #[cfg_attr(feature = "json_schema", schemars(rename = "flags"))]
74 #[cfg_attr(feature = "serde", serde(rename = "flags"))]
75 pub m_flags: i16,
76 #[cfg_attr(feature = "json_schema", schemars(rename = "subtractLastChild"))]
81 #[cfg_attr(feature = "serde", serde(rename = "subtractLastChild"))]
82 pub m_subtractLastChild: bool,
83 #[cfg_attr(feature = "json_schema", schemars(rename = "children"))]
88 #[cfg_attr(feature = "serde", serde(rename = "children"))]
89 pub m_children: Vec<Pointer>,
90 #[cfg_attr(feature = "json_schema", schemars(rename = "childrenInternalStates"))]
96 #[cfg_attr(feature = "serde", serde(rename = "childrenInternalStates"))]
97 pub m_childrenInternalStates: Vec<()>,
98 #[cfg_attr(feature = "json_schema", schemars(rename = "sortedChildren"))]
104 #[cfg_attr(feature = "serde", serde(rename = "sortedChildren"))]
105 pub m_sortedChildren: Vec<()>,
106 #[cfg_attr(feature = "json_schema", schemars(rename = "endIntervalWeight"))]
112 #[cfg_attr(feature = "serde", serde(rename = "endIntervalWeight"))]
113 pub m_endIntervalWeight: f32,
114 #[cfg_attr(feature = "json_schema", schemars(rename = "numActiveChildren"))]
120 #[cfg_attr(feature = "serde", serde(rename = "numActiveChildren"))]
121 pub m_numActiveChildren: i32,
122 #[cfg_attr(feature = "json_schema", schemars(rename = "beginIntervalIndex"))]
128 #[cfg_attr(feature = "serde", serde(rename = "beginIntervalIndex"))]
129 pub m_beginIntervalIndex: i16,
130 #[cfg_attr(feature = "json_schema", schemars(rename = "endIntervalIndex"))]
136 #[cfg_attr(feature = "serde", serde(rename = "endIntervalIndex"))]
137 pub m_endIntervalIndex: i16,
138 #[cfg_attr(feature = "json_schema", schemars(rename = "initSync"))]
144 #[cfg_attr(feature = "serde", serde(rename = "initSync"))]
145 pub m_initSync: bool,
146 #[cfg_attr(feature = "json_schema", schemars(rename = "doSubtractiveBlend"))]
152 #[cfg_attr(feature = "serde", serde(rename = "doSubtractiveBlend"))]
153 pub m_doSubtractiveBlend: bool,
154}
155const _: () = {
156 use havok_serde as _serde;
157 impl<'a> _serde::HavokClass for hkbBlenderGenerator<'a> {
158 #[inline]
159 fn name(&self) -> &'static str {
160 "hkbBlenderGenerator"
161 }
162 #[inline]
163 fn signature(&self) -> _serde::__private::Signature {
164 _serde::__private::Signature::new(0x22df7147)
165 }
166 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
167 fn deps_indexes(&self) -> Vec<usize> {
168 let mut v = Vec::new();
169 v.push(self.parent.parent.parent.m_variableBindingSet.get());
170 v.extend(self.m_children.iter().map(|ptr| ptr.get()));
171 v
172 }
173 }
174 impl<'a> _serde::Serialize for hkbBlenderGenerator<'a> {
175 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
176 where
177 S: _serde::ser::Serializer,
178 {
179 let class_meta = self
180 .__ptr
181 .map(|name| (name, _serde::__private::Signature::new(0x22df7147)));
182 let mut serializer = __serializer
183 .serialize_struct("hkbBlenderGenerator", class_meta, (116u64, 160u64))?;
184 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
185 serializer
186 .skip_field(
187 "memSizeAndFlags",
188 &self.parent.parent.parent.parent.m_memSizeAndFlags,
189 )?;
190 serializer
191 .skip_field(
192 "referenceCount",
193 &self.parent.parent.parent.parent.m_referenceCount,
194 )?;
195 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
196 serializer
197 .serialize_field(
198 "variableBindingSet",
199 &self.parent.parent.parent.m_variableBindingSet,
200 )?;
201 serializer
202 .skip_array_field(
203 "cachedBindables",
204 &self.parent.parent.parent.m_cachedBindables,
205 TypeSize::NonPtr,
206 )?;
207 serializer
208 .skip_field(
209 "areBindablesCached",
210 &self.parent.parent.parent.m_areBindablesCached,
211 )?;
212 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
213 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
214 serializer.serialize_field("name", &self.parent.parent.m_name)?;
215 serializer.skip_field("id", &self.parent.parent.m_id)?;
216 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
217 serializer
218 .skip_fixed_array_field(
219 "padNode",
220 self.parent.parent.m_padNode.as_slice(),
221 TypeSize::NonPtr,
222 )?;
223 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
224 serializer
225 .serialize_field(
226 "referencePoseWeightThreshold",
227 &self.m_referencePoseWeightThreshold,
228 )?;
229 serializer.serialize_field("blendParameter", &self.m_blendParameter)?;
230 serializer
231 .serialize_field(
232 "minCyclicBlendParameter",
233 &self.m_minCyclicBlendParameter,
234 )?;
235 serializer
236 .serialize_field(
237 "maxCyclicBlendParameter",
238 &self.m_maxCyclicBlendParameter,
239 )?;
240 serializer
241 .serialize_field(
242 "indexOfSyncMasterChild",
243 &self.m_indexOfSyncMasterChild,
244 )?;
245 serializer.serialize_field("flags", &self.m_flags)?;
246 serializer.serialize_field("subtractLastChild", &self.m_subtractLastChild)?;
247 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
248 serializer
249 .serialize_array_field("children", &self.m_children, TypeSize::NonPtr)?;
250 serializer
251 .skip_array_field(
252 "childrenInternalStates",
253 &self.m_childrenInternalStates,
254 TypeSize::NonPtr,
255 )?;
256 serializer
257 .skip_array_field(
258 "sortedChildren",
259 &self.m_sortedChildren,
260 TypeSize::NonPtr,
261 )?;
262 serializer.skip_field("endIntervalWeight", &self.m_endIntervalWeight)?;
263 serializer.skip_field("numActiveChildren", &self.m_numActiveChildren)?;
264 serializer.skip_field("beginIntervalIndex", &self.m_beginIntervalIndex)?;
265 serializer.skip_field("endIntervalIndex", &self.m_endIntervalIndex)?;
266 serializer.skip_field("initSync", &self.m_initSync)?;
267 serializer.skip_field("doSubtractiveBlend", &self.m_doSubtractiveBlend)?;
268 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
269 serializer.end()
270 }
271 }
272};
273#[doc(hidden)]
274#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
275const _: () = {
276 use havok_serde as _serde;
277 #[automatically_derived]
278 impl<'de> _serde::Deserialize<'de> for hkbBlenderGenerator<'de> {
279 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
280 where
281 __D: _serde::Deserializer<'de>,
282 {
283 #[allow(non_camel_case_types)]
284 enum __Field {
285 m_variableBindingSet,
286 m_userData,
287 m_name,
288 m_referencePoseWeightThreshold,
289 m_blendParameter,
290 m_minCyclicBlendParameter,
291 m_maxCyclicBlendParameter,
292 m_indexOfSyncMasterChild,
293 m_flags,
294 m_subtractLastChild,
295 m_children,
296 __ignore,
297 }
298 struct __FieldVisitor;
299 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
300 type Value = __Field;
301 fn expecting(
302 &self,
303 __formatter: &mut core::fmt::Formatter,
304 ) -> core::fmt::Result {
305 core::fmt::Formatter::write_str(__formatter, "field identifier")
306 }
307 #[allow(clippy::match_single_binding)]
309 #[allow(clippy::reversed_empty_ranges)]
310 #[allow(clippy::single_match)]
311 fn visit_key<__E>(
312 self,
313 __value: &str,
314 ) -> core::result::Result<Self::Value, __E>
315 where
316 __E: _serde::de::Error,
317 {
318 match __value {
319 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
320 "userData" => Ok(__Field::m_userData),
321 "name" => Ok(__Field::m_name),
322 "referencePoseWeightThreshold" => {
323 Ok(__Field::m_referencePoseWeightThreshold)
324 }
325 "blendParameter" => Ok(__Field::m_blendParameter),
326 "minCyclicBlendParameter" => {
327 Ok(__Field::m_minCyclicBlendParameter)
328 }
329 "maxCyclicBlendParameter" => {
330 Ok(__Field::m_maxCyclicBlendParameter)
331 }
332 "indexOfSyncMasterChild" => Ok(__Field::m_indexOfSyncMasterChild),
333 "flags" => Ok(__Field::m_flags),
334 "subtractLastChild" => Ok(__Field::m_subtractLastChild),
335 "children" => Ok(__Field::m_children),
336 _ => Ok(__Field::__ignore),
337 }
338 }
339 }
340 impl<'de> _serde::Deserialize<'de> for __Field {
341 #[inline]
342 fn deserialize<__D>(
343 __deserializer: __D,
344 ) -> core::result::Result<Self, __D::Error>
345 where
346 __D: _serde::Deserializer<'de>,
347 {
348 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
349 }
350 }
351 struct __hkbBlenderGeneratorVisitor<'de> {
352 marker: _serde::__private::PhantomData<hkbBlenderGenerator<'de>>,
353 lifetime: _serde::__private::PhantomData<&'de ()>,
354 }
355 #[allow(clippy::match_single_binding)]
356 #[allow(clippy::reversed_empty_ranges)]
357 #[allow(clippy::single_match)]
358 impl<'de> _serde::de::Visitor<'de> for __hkbBlenderGeneratorVisitor<'de> {
359 type Value = hkbBlenderGenerator<'de>;
360 fn expecting(
361 &self,
362 __formatter: &mut core::fmt::Formatter,
363 ) -> core::fmt::Result {
364 core::fmt::Formatter::write_str(
365 __formatter,
366 "struct hkbBlenderGenerator",
367 )
368 }
369 fn visit_struct_for_bytes<__A>(
370 self,
371 mut __map: __A,
372 ) -> _serde::__private::Result<Self::Value, __A::Error>
373 where
374 __A: _serde::de::MapAccess<'de>,
375 {
376 let __ptr = __A::class_ptr(&mut __map);
377 let parent = __A::parent_value(&mut __map)?;
378 let mut m_referencePoseWeightThreshold: _serde::__private::Option<
379 f32,
380 > = _serde::__private::None;
381 let mut m_blendParameter: _serde::__private::Option<f32> = _serde::__private::None;
382 let mut m_minCyclicBlendParameter: _serde::__private::Option<f32> = _serde::__private::None;
383 let mut m_maxCyclicBlendParameter: _serde::__private::Option<f32> = _serde::__private::None;
384 let mut m_indexOfSyncMasterChild: _serde::__private::Option<i16> = _serde::__private::None;
385 let mut m_flags: _serde::__private::Option<i16> = _serde::__private::None;
386 let mut m_subtractLastChild: _serde::__private::Option<bool> = _serde::__private::None;
387 let mut m_children: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
388 let mut m_childrenInternalStates: _serde::__private::Option<
389 Vec<()>,
390 > = _serde::__private::None;
391 let mut m_sortedChildren: _serde::__private::Option<Vec<()>> = _serde::__private::None;
392 let mut m_endIntervalWeight: _serde::__private::Option<f32> = _serde::__private::None;
393 let mut m_numActiveChildren: _serde::__private::Option<i32> = _serde::__private::None;
394 let mut m_beginIntervalIndex: _serde::__private::Option<i16> = _serde::__private::None;
395 let mut m_endIntervalIndex: _serde::__private::Option<i16> = _serde::__private::None;
396 let mut m_initSync: _serde::__private::Option<bool> = _serde::__private::None;
397 let mut m_doSubtractiveBlend: _serde::__private::Option<bool> = _serde::__private::None;
398 for i in 0..16usize {
399 match i {
400 0usize => {
401 if _serde::__private::Option::is_some(
402 &m_referencePoseWeightThreshold,
403 ) {
404 return _serde::__private::Err(
405 <__A::Error as _serde::de::Error>::duplicate_field(
406 "referencePoseWeightThreshold",
407 ),
408 );
409 }
410 m_referencePoseWeightThreshold = _serde::__private::Some(
411 match __A::next_value::<f32>(&mut __map) {
412 _serde::__private::Ok(__val) => __val,
413 _serde::__private::Err(__err) => {
414 return _serde::__private::Err(__err);
415 }
416 },
417 );
418 }
419 1usize => {
420 if _serde::__private::Option::is_some(&m_blendParameter) {
421 return _serde::__private::Err(
422 <__A::Error as _serde::de::Error>::duplicate_field(
423 "blendParameter",
424 ),
425 );
426 }
427 m_blendParameter = _serde::__private::Some(
428 match __A::next_value::<f32>(&mut __map) {
429 _serde::__private::Ok(__val) => __val,
430 _serde::__private::Err(__err) => {
431 return _serde::__private::Err(__err);
432 }
433 },
434 );
435 }
436 2usize => {
437 if _serde::__private::Option::is_some(
438 &m_minCyclicBlendParameter,
439 ) {
440 return _serde::__private::Err(
441 <__A::Error as _serde::de::Error>::duplicate_field(
442 "minCyclicBlendParameter",
443 ),
444 );
445 }
446 m_minCyclicBlendParameter = _serde::__private::Some(
447 match __A::next_value::<f32>(&mut __map) {
448 _serde::__private::Ok(__val) => __val,
449 _serde::__private::Err(__err) => {
450 return _serde::__private::Err(__err);
451 }
452 },
453 );
454 }
455 3usize => {
456 if _serde::__private::Option::is_some(
457 &m_maxCyclicBlendParameter,
458 ) {
459 return _serde::__private::Err(
460 <__A::Error as _serde::de::Error>::duplicate_field(
461 "maxCyclicBlendParameter",
462 ),
463 );
464 }
465 m_maxCyclicBlendParameter = _serde::__private::Some(
466 match __A::next_value::<f32>(&mut __map) {
467 _serde::__private::Ok(__val) => __val,
468 _serde::__private::Err(__err) => {
469 return _serde::__private::Err(__err);
470 }
471 },
472 );
473 }
474 4usize => {
475 if _serde::__private::Option::is_some(
476 &m_indexOfSyncMasterChild,
477 ) {
478 return _serde::__private::Err(
479 <__A::Error as _serde::de::Error>::duplicate_field(
480 "indexOfSyncMasterChild",
481 ),
482 );
483 }
484 m_indexOfSyncMasterChild = _serde::__private::Some(
485 match __A::next_value::<i16>(&mut __map) {
486 _serde::__private::Ok(__val) => __val,
487 _serde::__private::Err(__err) => {
488 return _serde::__private::Err(__err);
489 }
490 },
491 );
492 }
493 5usize => {
494 if _serde::__private::Option::is_some(&m_flags) {
495 return _serde::__private::Err(
496 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
497 );
498 }
499 m_flags = _serde::__private::Some(
500 match __A::next_value::<i16>(&mut __map) {
501 _serde::__private::Ok(__val) => __val,
502 _serde::__private::Err(__err) => {
503 return _serde::__private::Err(__err);
504 }
505 },
506 );
507 }
508 6usize => {
509 if _serde::__private::Option::is_some(
510 &m_subtractLastChild,
511 ) {
512 return _serde::__private::Err(
513 <__A::Error as _serde::de::Error>::duplicate_field(
514 "subtractLastChild",
515 ),
516 );
517 }
518 m_subtractLastChild = _serde::__private::Some(
519 match __A::next_value::<bool>(&mut __map) {
520 _serde::__private::Ok(__val) => __val,
521 _serde::__private::Err(__err) => {
522 return _serde::__private::Err(__err);
523 }
524 },
525 );
526 }
527 7usize => {
528 if _serde::__private::Option::is_some(&m_children) {
529 return _serde::__private::Err(
530 <__A::Error as _serde::de::Error>::duplicate_field(
531 "children",
532 ),
533 );
534 }
535 __A::pad(&mut __map, 3usize, 3usize)?;
536 m_children = _serde::__private::Some(
537 match __A::next_value::<Vec<Pointer>>(&mut __map) {
538 _serde::__private::Ok(__val) => __val,
539 _serde::__private::Err(__err) => {
540 return _serde::__private::Err(__err);
541 }
542 },
543 );
544 }
545 8usize => {
546 if _serde::__private::Option::is_some(
547 &m_childrenInternalStates,
548 ) {
549 return _serde::__private::Err(
550 <__A::Error as _serde::de::Error>::duplicate_field(
551 "childrenInternalStates",
552 ),
553 );
554 }
555 m_childrenInternalStates = _serde::__private::Some(
556 match __A::next_value::<Vec<()>>(&mut __map) {
557 _serde::__private::Ok(__val) => __val,
558 _serde::__private::Err(__err) => {
559 return _serde::__private::Err(__err);
560 }
561 },
562 );
563 }
564 9usize => {
565 if _serde::__private::Option::is_some(&m_sortedChildren) {
566 return _serde::__private::Err(
567 <__A::Error as _serde::de::Error>::duplicate_field(
568 "sortedChildren",
569 ),
570 );
571 }
572 m_sortedChildren = _serde::__private::Some(
573 match __A::next_value::<Vec<()>>(&mut __map) {
574 _serde::__private::Ok(__val) => __val,
575 _serde::__private::Err(__err) => {
576 return _serde::__private::Err(__err);
577 }
578 },
579 );
580 }
581 10usize => {
582 if _serde::__private::Option::is_some(
583 &m_endIntervalWeight,
584 ) {
585 return _serde::__private::Err(
586 <__A::Error as _serde::de::Error>::duplicate_field(
587 "endIntervalWeight",
588 ),
589 );
590 }
591 m_endIntervalWeight = _serde::__private::Some(
592 match __A::next_value::<f32>(&mut __map) {
593 _serde::__private::Ok(__val) => __val,
594 _serde::__private::Err(__err) => {
595 return _serde::__private::Err(__err);
596 }
597 },
598 );
599 }
600 11usize => {
601 if _serde::__private::Option::is_some(
602 &m_numActiveChildren,
603 ) {
604 return _serde::__private::Err(
605 <__A::Error as _serde::de::Error>::duplicate_field(
606 "numActiveChildren",
607 ),
608 );
609 }
610 m_numActiveChildren = _serde::__private::Some(
611 match __A::next_value::<i32>(&mut __map) {
612 _serde::__private::Ok(__val) => __val,
613 _serde::__private::Err(__err) => {
614 return _serde::__private::Err(__err);
615 }
616 },
617 );
618 }
619 12usize => {
620 if _serde::__private::Option::is_some(
621 &m_beginIntervalIndex,
622 ) {
623 return _serde::__private::Err(
624 <__A::Error as _serde::de::Error>::duplicate_field(
625 "beginIntervalIndex",
626 ),
627 );
628 }
629 m_beginIntervalIndex = _serde::__private::Some(
630 match __A::next_value::<i16>(&mut __map) {
631 _serde::__private::Ok(__val) => __val,
632 _serde::__private::Err(__err) => {
633 return _serde::__private::Err(__err);
634 }
635 },
636 );
637 }
638 13usize => {
639 if _serde::__private::Option::is_some(&m_endIntervalIndex) {
640 return _serde::__private::Err(
641 <__A::Error as _serde::de::Error>::duplicate_field(
642 "endIntervalIndex",
643 ),
644 );
645 }
646 m_endIntervalIndex = _serde::__private::Some(
647 match __A::next_value::<i16>(&mut __map) {
648 _serde::__private::Ok(__val) => __val,
649 _serde::__private::Err(__err) => {
650 return _serde::__private::Err(__err);
651 }
652 },
653 );
654 }
655 14usize => {
656 if _serde::__private::Option::is_some(&m_initSync) {
657 return _serde::__private::Err(
658 <__A::Error as _serde::de::Error>::duplicate_field(
659 "initSync",
660 ),
661 );
662 }
663 m_initSync = _serde::__private::Some(
664 match __A::next_value::<bool>(&mut __map) {
665 _serde::__private::Ok(__val) => __val,
666 _serde::__private::Err(__err) => {
667 return _serde::__private::Err(__err);
668 }
669 },
670 );
671 }
672 15usize => {
673 if _serde::__private::Option::is_some(
674 &m_doSubtractiveBlend,
675 ) {
676 return _serde::__private::Err(
677 <__A::Error as _serde::de::Error>::duplicate_field(
678 "doSubtractiveBlend",
679 ),
680 );
681 }
682 m_doSubtractiveBlend = _serde::__private::Some(
683 match __A::next_value::<bool>(&mut __map) {
684 _serde::__private::Ok(__val) => __val,
685 _serde::__private::Err(__err) => {
686 return _serde::__private::Err(__err);
687 }
688 },
689 );
690 }
691 _ => {}
692 }
693 }
694 __A::pad(&mut __map, 2usize, 2usize)?;
695 let m_referencePoseWeightThreshold = match m_referencePoseWeightThreshold {
696 _serde::__private::Some(__field) => __field,
697 _serde::__private::None => {
698 return _serde::__private::Err(
699 <__A::Error as _serde::de::Error>::missing_field(
700 "referencePoseWeightThreshold",
701 ),
702 );
703 }
704 };
705 let m_blendParameter = match m_blendParameter {
706 _serde::__private::Some(__field) => __field,
707 _serde::__private::None => {
708 return _serde::__private::Err(
709 <__A::Error as _serde::de::Error>::missing_field(
710 "blendParameter",
711 ),
712 );
713 }
714 };
715 let m_minCyclicBlendParameter = match m_minCyclicBlendParameter {
716 _serde::__private::Some(__field) => __field,
717 _serde::__private::None => {
718 return _serde::__private::Err(
719 <__A::Error as _serde::de::Error>::missing_field(
720 "minCyclicBlendParameter",
721 ),
722 );
723 }
724 };
725 let m_maxCyclicBlendParameter = match m_maxCyclicBlendParameter {
726 _serde::__private::Some(__field) => __field,
727 _serde::__private::None => {
728 return _serde::__private::Err(
729 <__A::Error as _serde::de::Error>::missing_field(
730 "maxCyclicBlendParameter",
731 ),
732 );
733 }
734 };
735 let m_indexOfSyncMasterChild = match m_indexOfSyncMasterChild {
736 _serde::__private::Some(__field) => __field,
737 _serde::__private::None => {
738 return _serde::__private::Err(
739 <__A::Error as _serde::de::Error>::missing_field(
740 "indexOfSyncMasterChild",
741 ),
742 );
743 }
744 };
745 let m_flags = match m_flags {
746 _serde::__private::Some(__field) => __field,
747 _serde::__private::None => {
748 return _serde::__private::Err(
749 <__A::Error as _serde::de::Error>::missing_field("flags"),
750 );
751 }
752 };
753 let m_subtractLastChild = match m_subtractLastChild {
754 _serde::__private::Some(__field) => __field,
755 _serde::__private::None => {
756 return _serde::__private::Err(
757 <__A::Error as _serde::de::Error>::missing_field(
758 "subtractLastChild",
759 ),
760 );
761 }
762 };
763 let m_children = match m_children {
764 _serde::__private::Some(__field) => __field,
765 _serde::__private::None => {
766 return _serde::__private::Err(
767 <__A::Error as _serde::de::Error>::missing_field("children"),
768 );
769 }
770 };
771 let m_childrenInternalStates = match m_childrenInternalStates {
772 _serde::__private::Some(__field) => __field,
773 _serde::__private::None => {
774 return _serde::__private::Err(
775 <__A::Error as _serde::de::Error>::missing_field(
776 "childrenInternalStates",
777 ),
778 );
779 }
780 };
781 let m_sortedChildren = match m_sortedChildren {
782 _serde::__private::Some(__field) => __field,
783 _serde::__private::None => {
784 return _serde::__private::Err(
785 <__A::Error as _serde::de::Error>::missing_field(
786 "sortedChildren",
787 ),
788 );
789 }
790 };
791 let m_endIntervalWeight = match m_endIntervalWeight {
792 _serde::__private::Some(__field) => __field,
793 _serde::__private::None => {
794 return _serde::__private::Err(
795 <__A::Error as _serde::de::Error>::missing_field(
796 "endIntervalWeight",
797 ),
798 );
799 }
800 };
801 let m_numActiveChildren = match m_numActiveChildren {
802 _serde::__private::Some(__field) => __field,
803 _serde::__private::None => {
804 return _serde::__private::Err(
805 <__A::Error as _serde::de::Error>::missing_field(
806 "numActiveChildren",
807 ),
808 );
809 }
810 };
811 let m_beginIntervalIndex = match m_beginIntervalIndex {
812 _serde::__private::Some(__field) => __field,
813 _serde::__private::None => {
814 return _serde::__private::Err(
815 <__A::Error as _serde::de::Error>::missing_field(
816 "beginIntervalIndex",
817 ),
818 );
819 }
820 };
821 let m_endIntervalIndex = match m_endIntervalIndex {
822 _serde::__private::Some(__field) => __field,
823 _serde::__private::None => {
824 return _serde::__private::Err(
825 <__A::Error as _serde::de::Error>::missing_field(
826 "endIntervalIndex",
827 ),
828 );
829 }
830 };
831 let m_initSync = match m_initSync {
832 _serde::__private::Some(__field) => __field,
833 _serde::__private::None => {
834 return _serde::__private::Err(
835 <__A::Error as _serde::de::Error>::missing_field("initSync"),
836 );
837 }
838 };
839 let m_doSubtractiveBlend = match m_doSubtractiveBlend {
840 _serde::__private::Some(__field) => __field,
841 _serde::__private::None => {
842 return _serde::__private::Err(
843 <__A::Error as _serde::de::Error>::missing_field(
844 "doSubtractiveBlend",
845 ),
846 );
847 }
848 };
849 _serde::__private::Ok(hkbBlenderGenerator {
850 __ptr,
851 parent,
852 m_referencePoseWeightThreshold,
853 m_blendParameter,
854 m_minCyclicBlendParameter,
855 m_maxCyclicBlendParameter,
856 m_indexOfSyncMasterChild,
857 m_flags,
858 m_subtractLastChild,
859 m_children,
860 m_childrenInternalStates,
861 m_sortedChildren,
862 m_endIntervalWeight,
863 m_numActiveChildren,
864 m_beginIntervalIndex,
865 m_endIntervalIndex,
866 m_initSync,
867 m_doSubtractiveBlend,
868 })
869 }
870 #[allow(clippy::manual_unwrap_or_default)]
871 fn visit_struct<__A>(
872 self,
873 mut __map: __A,
874 ) -> _serde::__private::Result<Self::Value, __A::Error>
875 where
876 __A: _serde::de::MapAccess<'de>,
877 {
878 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
879 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
880 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
881 let mut m_referencePoseWeightThreshold: _serde::__private::Option<
882 f32,
883 > = _serde::__private::None;
884 let mut m_blendParameter: _serde::__private::Option<f32> = _serde::__private::None;
885 let mut m_minCyclicBlendParameter: _serde::__private::Option<f32> = _serde::__private::None;
886 let mut m_maxCyclicBlendParameter: _serde::__private::Option<f32> = _serde::__private::None;
887 let mut m_indexOfSyncMasterChild: _serde::__private::Option<i16> = _serde::__private::None;
888 let mut m_flags: _serde::__private::Option<i16> = _serde::__private::None;
889 let mut m_subtractLastChild: _serde::__private::Option<bool> = _serde::__private::None;
890 let mut m_children: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
891 while let _serde::__private::Some(__key) = {
892 __A::next_key::<__Field>(&mut __map)?
893 } {
894 match __key {
895 __Field::m_variableBindingSet => {
896 #[cfg(
897 any(feature = "strict", feature = "ignore_duplicates")
898 )]
899 if _serde::__private::Option::is_some(
900 &m_variableBindingSet,
901 ) {
902 #[cfg(feature = "ignore_duplicates")]
903 {
904 __A::skip_value(&mut __map)?;
905 continue;
906 }
907 #[cfg(feature = "strict")]
908 return _serde::__private::Err(
909 <__A::Error as _serde::de::Error>::duplicate_field(
910 "variableBindingSet",
911 ),
912 );
913 }
914 m_variableBindingSet = _serde::__private::Some(
915 match __A::next_value::<Pointer>(&mut __map) {
916 _serde::__private::Ok(__val) => __val,
917 _serde::__private::Err(__err) => {
918 return _serde::__private::Err(__err);
919 }
920 },
921 );
922 }
923 __Field::m_userData => {
924 #[cfg(
925 any(feature = "strict", feature = "ignore_duplicates")
926 )]
927 if _serde::__private::Option::is_some(&m_userData) {
928 #[cfg(feature = "ignore_duplicates")]
929 {
930 __A::skip_value(&mut __map)?;
931 continue;
932 }
933 #[cfg(feature = "strict")]
934 return _serde::__private::Err(
935 <__A::Error as _serde::de::Error>::duplicate_field(
936 "userData",
937 ),
938 );
939 }
940 m_userData = _serde::__private::Some(
941 match __A::next_value::<Ulong>(&mut __map) {
942 _serde::__private::Ok(__val) => __val,
943 _serde::__private::Err(__err) => {
944 return _serde::__private::Err(__err);
945 }
946 },
947 );
948 }
949 __Field::m_name => {
950 #[cfg(
951 any(feature = "strict", feature = "ignore_duplicates")
952 )]
953 if _serde::__private::Option::is_some(&m_name) {
954 #[cfg(feature = "ignore_duplicates")]
955 {
956 __A::skip_value(&mut __map)?;
957 continue;
958 }
959 #[cfg(feature = "strict")]
960 return _serde::__private::Err(
961 <__A::Error as _serde::de::Error>::duplicate_field("name"),
962 );
963 }
964 m_name = _serde::__private::Some(
965 match __A::next_value::<StringPtr<'de>>(&mut __map) {
966 _serde::__private::Ok(__val) => __val,
967 _serde::__private::Err(__err) => {
968 return _serde::__private::Err(__err);
969 }
970 },
971 );
972 }
973 __Field::m_referencePoseWeightThreshold => {
974 #[cfg(
975 any(feature = "strict", feature = "ignore_duplicates")
976 )]
977 if _serde::__private::Option::is_some(
978 &m_referencePoseWeightThreshold,
979 ) {
980 #[cfg(feature = "ignore_duplicates")]
981 {
982 __A::skip_value(&mut __map)?;
983 continue;
984 }
985 #[cfg(feature = "strict")]
986 return _serde::__private::Err(
987 <__A::Error as _serde::de::Error>::duplicate_field(
988 "referencePoseWeightThreshold",
989 ),
990 );
991 }
992 m_referencePoseWeightThreshold = _serde::__private::Some(
993 match __A::next_value::<f32>(&mut __map) {
994 _serde::__private::Ok(__val) => __val,
995 _serde::__private::Err(__err) => {
996 return _serde::__private::Err(__err);
997 }
998 },
999 );
1000 }
1001 __Field::m_blendParameter => {
1002 #[cfg(
1003 any(feature = "strict", feature = "ignore_duplicates")
1004 )]
1005 if _serde::__private::Option::is_some(&m_blendParameter) {
1006 #[cfg(feature = "ignore_duplicates")]
1007 {
1008 __A::skip_value(&mut __map)?;
1009 continue;
1010 }
1011 #[cfg(feature = "strict")]
1012 return _serde::__private::Err(
1013 <__A::Error as _serde::de::Error>::duplicate_field(
1014 "blendParameter",
1015 ),
1016 );
1017 }
1018 m_blendParameter = _serde::__private::Some(
1019 match __A::next_value::<f32>(&mut __map) {
1020 _serde::__private::Ok(__val) => __val,
1021 _serde::__private::Err(__err) => {
1022 return _serde::__private::Err(__err);
1023 }
1024 },
1025 );
1026 }
1027 __Field::m_minCyclicBlendParameter => {
1028 #[cfg(
1029 any(feature = "strict", feature = "ignore_duplicates")
1030 )]
1031 if _serde::__private::Option::is_some(
1032 &m_minCyclicBlendParameter,
1033 ) {
1034 #[cfg(feature = "ignore_duplicates")]
1035 {
1036 __A::skip_value(&mut __map)?;
1037 continue;
1038 }
1039 #[cfg(feature = "strict")]
1040 return _serde::__private::Err(
1041 <__A::Error as _serde::de::Error>::duplicate_field(
1042 "minCyclicBlendParameter",
1043 ),
1044 );
1045 }
1046 m_minCyclicBlendParameter = _serde::__private::Some(
1047 match __A::next_value::<f32>(&mut __map) {
1048 _serde::__private::Ok(__val) => __val,
1049 _serde::__private::Err(__err) => {
1050 return _serde::__private::Err(__err);
1051 }
1052 },
1053 );
1054 }
1055 __Field::m_maxCyclicBlendParameter => {
1056 #[cfg(
1057 any(feature = "strict", feature = "ignore_duplicates")
1058 )]
1059 if _serde::__private::Option::is_some(
1060 &m_maxCyclicBlendParameter,
1061 ) {
1062 #[cfg(feature = "ignore_duplicates")]
1063 {
1064 __A::skip_value(&mut __map)?;
1065 continue;
1066 }
1067 #[cfg(feature = "strict")]
1068 return _serde::__private::Err(
1069 <__A::Error as _serde::de::Error>::duplicate_field(
1070 "maxCyclicBlendParameter",
1071 ),
1072 );
1073 }
1074 m_maxCyclicBlendParameter = _serde::__private::Some(
1075 match __A::next_value::<f32>(&mut __map) {
1076 _serde::__private::Ok(__val) => __val,
1077 _serde::__private::Err(__err) => {
1078 return _serde::__private::Err(__err);
1079 }
1080 },
1081 );
1082 }
1083 __Field::m_indexOfSyncMasterChild => {
1084 #[cfg(
1085 any(feature = "strict", feature = "ignore_duplicates")
1086 )]
1087 if _serde::__private::Option::is_some(
1088 &m_indexOfSyncMasterChild,
1089 ) {
1090 #[cfg(feature = "ignore_duplicates")]
1091 {
1092 __A::skip_value(&mut __map)?;
1093 continue;
1094 }
1095 #[cfg(feature = "strict")]
1096 return _serde::__private::Err(
1097 <__A::Error as _serde::de::Error>::duplicate_field(
1098 "indexOfSyncMasterChild",
1099 ),
1100 );
1101 }
1102 m_indexOfSyncMasterChild = _serde::__private::Some(
1103 match __A::next_value::<i16>(&mut __map) {
1104 _serde::__private::Ok(__val) => __val,
1105 _serde::__private::Err(__err) => {
1106 return _serde::__private::Err(__err);
1107 }
1108 },
1109 );
1110 }
1111 __Field::m_flags => {
1112 #[cfg(
1113 any(feature = "strict", feature = "ignore_duplicates")
1114 )]
1115 if _serde::__private::Option::is_some(&m_flags) {
1116 #[cfg(feature = "ignore_duplicates")]
1117 {
1118 __A::skip_value(&mut __map)?;
1119 continue;
1120 }
1121 #[cfg(feature = "strict")]
1122 return _serde::__private::Err(
1123 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
1124 );
1125 }
1126 m_flags = _serde::__private::Some(
1127 match __A::next_value::<i16>(&mut __map) {
1128 _serde::__private::Ok(__val) => __val,
1129 _serde::__private::Err(__err) => {
1130 return _serde::__private::Err(__err);
1131 }
1132 },
1133 );
1134 }
1135 __Field::m_subtractLastChild => {
1136 #[cfg(
1137 any(feature = "strict", feature = "ignore_duplicates")
1138 )]
1139 if _serde::__private::Option::is_some(
1140 &m_subtractLastChild,
1141 ) {
1142 #[cfg(feature = "ignore_duplicates")]
1143 {
1144 __A::skip_value(&mut __map)?;
1145 continue;
1146 }
1147 #[cfg(feature = "strict")]
1148 return _serde::__private::Err(
1149 <__A::Error as _serde::de::Error>::duplicate_field(
1150 "subtractLastChild",
1151 ),
1152 );
1153 }
1154 m_subtractLastChild = _serde::__private::Some(
1155 match __A::next_value::<bool>(&mut __map) {
1156 _serde::__private::Ok(__val) => __val,
1157 _serde::__private::Err(__err) => {
1158 return _serde::__private::Err(__err);
1159 }
1160 },
1161 );
1162 }
1163 __Field::m_children => {
1164 #[cfg(
1165 any(feature = "strict", feature = "ignore_duplicates")
1166 )]
1167 if _serde::__private::Option::is_some(&m_children) {
1168 #[cfg(feature = "ignore_duplicates")]
1169 {
1170 __A::skip_value(&mut __map)?;
1171 continue;
1172 }
1173 #[cfg(feature = "strict")]
1174 return _serde::__private::Err(
1175 <__A::Error as _serde::de::Error>::duplicate_field(
1176 "children",
1177 ),
1178 );
1179 }
1180 m_children = _serde::__private::Some(
1181 match __A::next_value::<Vec<Pointer>>(&mut __map) {
1182 _serde::__private::Ok(__val) => __val,
1183 _serde::__private::Err(__err) => {
1184 return _serde::__private::Err(__err);
1185 }
1186 },
1187 );
1188 }
1189 _ => __A::skip_value(&mut __map)?,
1190 }
1191 }
1192 let m_variableBindingSet = match m_variableBindingSet {
1193 _serde::__private::Some(__field) => __field,
1194 _serde::__private::None => {
1195 #[cfg(feature = "strict")]
1196 return _serde::__private::Err(
1197 <__A::Error as _serde::de::Error>::missing_field(
1198 "variableBindingSet",
1199 ),
1200 );
1201 #[cfg(not(feature = "strict"))] Default::default()
1202 }
1203 };
1204 let m_userData = match m_userData {
1205 _serde::__private::Some(__field) => __field,
1206 _serde::__private::None => {
1207 #[cfg(feature = "strict")]
1208 return _serde::__private::Err(
1209 <__A::Error as _serde::de::Error>::missing_field("userData"),
1210 );
1211 #[cfg(not(feature = "strict"))] Default::default()
1212 }
1213 };
1214 let m_name = match m_name {
1215 _serde::__private::Some(__field) => __field,
1216 _serde::__private::None => {
1217 #[cfg(feature = "strict")]
1218 return _serde::__private::Err(
1219 <__A::Error as _serde::de::Error>::missing_field("name"),
1220 );
1221 #[cfg(not(feature = "strict"))] Default::default()
1222 }
1223 };
1224 let m_referencePoseWeightThreshold = match m_referencePoseWeightThreshold {
1225 _serde::__private::Some(__field) => __field,
1226 _serde::__private::None => {
1227 #[cfg(feature = "strict")]
1228 return _serde::__private::Err(
1229 <__A::Error as _serde::de::Error>::missing_field(
1230 "referencePoseWeightThreshold",
1231 ),
1232 );
1233 #[cfg(not(feature = "strict"))] Default::default()
1234 }
1235 };
1236 let m_blendParameter = match m_blendParameter {
1237 _serde::__private::Some(__field) => __field,
1238 _serde::__private::None => {
1239 #[cfg(feature = "strict")]
1240 return _serde::__private::Err(
1241 <__A::Error as _serde::de::Error>::missing_field(
1242 "blendParameter",
1243 ),
1244 );
1245 #[cfg(not(feature = "strict"))] Default::default()
1246 }
1247 };
1248 let m_minCyclicBlendParameter = match m_minCyclicBlendParameter {
1249 _serde::__private::Some(__field) => __field,
1250 _serde::__private::None => {
1251 #[cfg(feature = "strict")]
1252 return _serde::__private::Err(
1253 <__A::Error as _serde::de::Error>::missing_field(
1254 "minCyclicBlendParameter",
1255 ),
1256 );
1257 #[cfg(not(feature = "strict"))] Default::default()
1258 }
1259 };
1260 let m_maxCyclicBlendParameter = match m_maxCyclicBlendParameter {
1261 _serde::__private::Some(__field) => __field,
1262 _serde::__private::None => {
1263 #[cfg(feature = "strict")]
1264 return _serde::__private::Err(
1265 <__A::Error as _serde::de::Error>::missing_field(
1266 "maxCyclicBlendParameter",
1267 ),
1268 );
1269 #[cfg(not(feature = "strict"))] Default::default()
1270 }
1271 };
1272 let m_indexOfSyncMasterChild = match m_indexOfSyncMasterChild {
1273 _serde::__private::Some(__field) => __field,
1274 _serde::__private::None => {
1275 #[cfg(feature = "strict")]
1276 return _serde::__private::Err(
1277 <__A::Error as _serde::de::Error>::missing_field(
1278 "indexOfSyncMasterChild",
1279 ),
1280 );
1281 #[cfg(not(feature = "strict"))] Default::default()
1282 }
1283 };
1284 let m_flags = match m_flags {
1285 _serde::__private::Some(__field) => __field,
1286 _serde::__private::None => {
1287 #[cfg(feature = "strict")]
1288 return _serde::__private::Err(
1289 <__A::Error as _serde::de::Error>::missing_field("flags"),
1290 );
1291 #[cfg(not(feature = "strict"))] Default::default()
1292 }
1293 };
1294 let m_subtractLastChild = match m_subtractLastChild {
1295 _serde::__private::Some(__field) => __field,
1296 _serde::__private::None => {
1297 #[cfg(feature = "strict")]
1298 return _serde::__private::Err(
1299 <__A::Error as _serde::de::Error>::missing_field(
1300 "subtractLastChild",
1301 ),
1302 );
1303 #[cfg(not(feature = "strict"))] Default::default()
1304 }
1305 };
1306 let m_children = match m_children {
1307 _serde::__private::Some(__field) => __field,
1308 _serde::__private::None => {
1309 #[cfg(feature = "strict")]
1310 return _serde::__private::Err(
1311 <__A::Error as _serde::de::Error>::missing_field("children"),
1312 );
1313 #[cfg(not(feature = "strict"))] Default::default()
1314 }
1315 };
1316 let __ptr = None;
1317 let parent = hkBaseObject { __ptr };
1318 let parent = hkReferencedObject {
1319 __ptr,
1320 parent,
1321 ..Default::default()
1322 };
1323 let parent = hkbBindable {
1324 __ptr,
1325 parent,
1326 m_variableBindingSet,
1327 ..Default::default()
1328 };
1329 let parent = hkbNode {
1330 __ptr,
1331 parent,
1332 m_userData,
1333 m_name,
1334 ..Default::default()
1335 };
1336 let parent = hkbGenerator { __ptr, parent };
1337 let __ptr = __A::class_ptr(&mut __map);
1338 _serde::__private::Ok(hkbBlenderGenerator {
1339 __ptr,
1340 parent,
1341 m_referencePoseWeightThreshold,
1342 m_blendParameter,
1343 m_minCyclicBlendParameter,
1344 m_maxCyclicBlendParameter,
1345 m_indexOfSyncMasterChild,
1346 m_flags,
1347 m_subtractLastChild,
1348 m_children,
1349 ..Default::default()
1350 })
1351 }
1352 }
1353 const FIELDS: &[&str] = &[
1354 "referencePoseWeightThreshold",
1355 "blendParameter",
1356 "minCyclicBlendParameter",
1357 "maxCyclicBlendParameter",
1358 "indexOfSyncMasterChild",
1359 "flags",
1360 "subtractLastChild",
1361 "children",
1362 "childrenInternalStates",
1363 "sortedChildren",
1364 "endIntervalWeight",
1365 "numActiveChildren",
1366 "beginIntervalIndex",
1367 "endIntervalIndex",
1368 "initSync",
1369 "doSubtractiveBlend",
1370 ];
1371 _serde::Deserializer::deserialize_struct(
1372 deserializer,
1373 "hkbBlenderGenerator",
1374 FIELDS,
1375 __hkbBlenderGeneratorVisitor {
1376 marker: _serde::__private::PhantomData::<hkbBlenderGenerator>,
1377 lifetime: _serde::__private::PhantomData,
1378 },
1379 )
1380 }
1381 }
1382};