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 BSCyclicBlendTransitionGenerator<'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(feature = "json_schema", schemars(rename = "pBlenderGenerator"))]
37 #[cfg_attr(feature = "serde", serde(rename = "pBlenderGenerator"))]
38 pub m_pBlenderGenerator: Pointer,
39 #[cfg_attr(feature = "json_schema", schemars(rename = "EventToFreezeBlendValue"))]
44 #[cfg_attr(feature = "serde", serde(rename = "EventToFreezeBlendValue"))]
45 pub m_EventToFreezeBlendValue: hkbEventProperty,
46 #[cfg_attr(feature = "json_schema", schemars(rename = "EventToCrossBlend"))]
51 #[cfg_attr(feature = "serde", serde(rename = "EventToCrossBlend"))]
52 pub m_EventToCrossBlend: hkbEventProperty,
53 #[cfg_attr(feature = "json_schema", schemars(rename = "fBlendParameter"))]
58 #[cfg_attr(feature = "serde", serde(rename = "fBlendParameter"))]
59 pub m_fBlendParameter: f32,
60 #[cfg_attr(feature = "json_schema", schemars(rename = "fTransitionDuration"))]
65 #[cfg_attr(feature = "serde", serde(rename = "fTransitionDuration"))]
66 pub m_fTransitionDuration: f32,
67 #[cfg_attr(feature = "json_schema", schemars(rename = "eBlendCurve"))]
72 #[cfg_attr(feature = "serde", serde(rename = "eBlendCurve"))]
73 pub m_eBlendCurve: BlendCurve,
74 #[cfg_attr(
80 feature = "json_schema",
81 schemars(rename = "pTransitionBlenderGenerator")
82 )]
83 #[cfg_attr(feature = "serde", serde(rename = "pTransitionBlenderGenerator"))]
84 pub m_pTransitionBlenderGenerator: Pointer,
85 #[cfg_attr(feature = "json_schema", schemars(rename = "pTransitionEffect"))]
91 #[cfg_attr(feature = "serde", serde(rename = "pTransitionEffect"))]
92 pub m_pTransitionEffect: Pointer,
93 #[cfg_attr(feature = "json_schema", schemars(rename = "currentMode"))]
99 #[cfg_attr(feature = "serde", serde(rename = "currentMode"))]
100 pub m_currentMode: i8,
101}
102const _: () = {
103 use havok_serde as _serde;
104 impl<'a> _serde::HavokClass for BSCyclicBlendTransitionGenerator<'a> {
105 #[inline]
106 fn name(&self) -> &'static str {
107 "BSCyclicBlendTransitionGenerator"
108 }
109 #[inline]
110 fn signature(&self) -> _serde::__private::Signature {
111 _serde::__private::Signature::new(0x5119eb06)
112 }
113 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
114 fn deps_indexes(&self) -> Vec<usize> {
115 let mut v = Vec::new();
116 v.push(self.parent.parent.parent.m_variableBindingSet.get());
117 v.push(self.m_pBlenderGenerator.get());
118 v.extend(self.m_EventToFreezeBlendValue.deps_indexes());
119 v.extend(self.m_EventToCrossBlend.deps_indexes());
120 v.push(self.m_pTransitionBlenderGenerator.get());
121 v.push(self.m_pTransitionEffect.get());
122 v
123 }
124 }
125 impl<'a> _serde::Serialize for BSCyclicBlendTransitionGenerator<'a> {
126 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
127 where
128 S: _serde::ser::Serializer,
129 {
130 let class_meta = self
131 .__ptr
132 .map(|name| (name, _serde::__private::Signature::new(0x5119eb06)));
133 let mut serializer = __serializer
134 .serialize_struct(
135 "BSCyclicBlendTransitionGenerator",
136 class_meta,
137 (112u64, 176u64),
138 )?;
139 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
140 serializer
141 .skip_field(
142 "memSizeAndFlags",
143 &self.parent.parent.parent.parent.m_memSizeAndFlags,
144 )?;
145 serializer
146 .skip_field(
147 "referenceCount",
148 &self.parent.parent.parent.parent.m_referenceCount,
149 )?;
150 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
151 serializer
152 .serialize_field(
153 "variableBindingSet",
154 &self.parent.parent.parent.m_variableBindingSet,
155 )?;
156 serializer
157 .skip_array_field(
158 "cachedBindables",
159 &self.parent.parent.parent.m_cachedBindables,
160 TypeSize::NonPtr,
161 )?;
162 serializer
163 .skip_field(
164 "areBindablesCached",
165 &self.parent.parent.parent.m_areBindablesCached,
166 )?;
167 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
168 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
169 serializer.serialize_field("name", &self.parent.parent.m_name)?;
170 serializer.skip_field("id", &self.parent.parent.m_id)?;
171 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
172 serializer
173 .skip_fixed_array_field(
174 "padNode",
175 self.parent.parent.m_padNode.as_slice(),
176 TypeSize::NonPtr,
177 )?;
178 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
179 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 8usize].as_slice())?;
180 serializer.serialize_field("pBlenderGenerator", &self.m_pBlenderGenerator)?;
181 serializer
182 .serialize_field(
183 "EventToFreezeBlendValue",
184 &self.m_EventToFreezeBlendValue,
185 )?;
186 serializer.serialize_field("EventToCrossBlend", &self.m_EventToCrossBlend)?;
187 serializer.serialize_field("fBlendParameter", &self.m_fBlendParameter)?;
188 serializer
189 .serialize_field("fTransitionDuration", &self.m_fTransitionDuration)?;
190 serializer.serialize_field("eBlendCurve", &self.m_eBlendCurve)?;
191 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 15usize].as_slice())?;
192 serializer
193 .skip_field(
194 "pTransitionBlenderGenerator",
195 &self.m_pTransitionBlenderGenerator,
196 )?;
197 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 8usize].as_slice())?;
198 serializer.skip_field("pTransitionEffect", &self.m_pTransitionEffect)?;
199 serializer.skip_field("currentMode", &self.m_currentMode)?;
200 serializer.pad_field([0u8; 11usize].as_slice(), [0u8; 7usize].as_slice())?;
201 serializer.end()
202 }
203 }
204};
205#[doc(hidden)]
206#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
207const _: () = {
208 use havok_serde as _serde;
209 #[automatically_derived]
210 impl<'de> _serde::Deserialize<'de> for BSCyclicBlendTransitionGenerator<'de> {
211 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
212 where
213 __D: _serde::Deserializer<'de>,
214 {
215 #[allow(non_camel_case_types)]
216 enum __Field {
217 m_variableBindingSet,
218 m_userData,
219 m_name,
220 m_pBlenderGenerator,
221 m_EventToFreezeBlendValue,
222 m_EventToCrossBlend,
223 m_fBlendParameter,
224 m_fTransitionDuration,
225 m_eBlendCurve,
226 __ignore,
227 }
228 struct __FieldVisitor;
229 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
230 type Value = __Field;
231 fn expecting(
232 &self,
233 __formatter: &mut core::fmt::Formatter,
234 ) -> core::fmt::Result {
235 core::fmt::Formatter::write_str(__formatter, "field identifier")
236 }
237 #[allow(clippy::match_single_binding)]
239 #[allow(clippy::reversed_empty_ranges)]
240 #[allow(clippy::single_match)]
241 fn visit_key<__E>(
242 self,
243 __value: &str,
244 ) -> core::result::Result<Self::Value, __E>
245 where
246 __E: _serde::de::Error,
247 {
248 match __value {
249 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
250 "userData" => Ok(__Field::m_userData),
251 "name" => Ok(__Field::m_name),
252 "pBlenderGenerator" => Ok(__Field::m_pBlenderGenerator),
253 "EventToFreezeBlendValue" => {
254 Ok(__Field::m_EventToFreezeBlendValue)
255 }
256 "EventToCrossBlend" => Ok(__Field::m_EventToCrossBlend),
257 "fBlendParameter" => Ok(__Field::m_fBlendParameter),
258 "fTransitionDuration" => Ok(__Field::m_fTransitionDuration),
259 "eBlendCurve" => Ok(__Field::m_eBlendCurve),
260 _ => Ok(__Field::__ignore),
261 }
262 }
263 }
264 impl<'de> _serde::Deserialize<'de> for __Field {
265 #[inline]
266 fn deserialize<__D>(
267 __deserializer: __D,
268 ) -> core::result::Result<Self, __D::Error>
269 where
270 __D: _serde::Deserializer<'de>,
271 {
272 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
273 }
274 }
275 struct __BSCyclicBlendTransitionGeneratorVisitor<'de> {
276 marker: _serde::__private::PhantomData<
277 BSCyclicBlendTransitionGenerator<'de>,
278 >,
279 lifetime: _serde::__private::PhantomData<&'de ()>,
280 }
281 #[allow(clippy::match_single_binding)]
282 #[allow(clippy::reversed_empty_ranges)]
283 #[allow(clippy::single_match)]
284 impl<'de> _serde::de::Visitor<'de>
285 for __BSCyclicBlendTransitionGeneratorVisitor<'de> {
286 type Value = BSCyclicBlendTransitionGenerator<'de>;
287 fn expecting(
288 &self,
289 __formatter: &mut core::fmt::Formatter,
290 ) -> core::fmt::Result {
291 core::fmt::Formatter::write_str(
292 __formatter,
293 "struct BSCyclicBlendTransitionGenerator",
294 )
295 }
296 fn visit_struct_for_bytes<__A>(
297 self,
298 mut __map: __A,
299 ) -> _serde::__private::Result<Self::Value, __A::Error>
300 where
301 __A: _serde::de::MapAccess<'de>,
302 {
303 let __ptr = __A::class_ptr(&mut __map);
304 let parent = __A::parent_value(&mut __map)?;
305 let mut m_pBlenderGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
306 let mut m_EventToFreezeBlendValue: _serde::__private::Option<
307 hkbEventProperty,
308 > = _serde::__private::None;
309 let mut m_EventToCrossBlend: _serde::__private::Option<
310 hkbEventProperty,
311 > = _serde::__private::None;
312 let mut m_fBlendParameter: _serde::__private::Option<f32> = _serde::__private::None;
313 let mut m_fTransitionDuration: _serde::__private::Option<f32> = _serde::__private::None;
314 let mut m_eBlendCurve: _serde::__private::Option<BlendCurve> = _serde::__private::None;
315 let mut m_pTransitionBlenderGenerator: _serde::__private::Option<
316 Pointer,
317 > = _serde::__private::None;
318 let mut m_pTransitionEffect: _serde::__private::Option<Pointer> = _serde::__private::None;
319 let mut m_currentMode: _serde::__private::Option<i8> = _serde::__private::None;
320 for i in 0..9usize {
321 match i {
322 0usize => {
323 if _serde::__private::Option::is_some(
324 &m_pBlenderGenerator,
325 ) {
326 return _serde::__private::Err(
327 <__A::Error as _serde::de::Error>::duplicate_field(
328 "pBlenderGenerator",
329 ),
330 );
331 }
332 __A::pad(&mut __map, 8usize, 8usize)?;
333 m_pBlenderGenerator = _serde::__private::Some(
334 match __A::next_value::<Pointer>(&mut __map) {
335 _serde::__private::Ok(__val) => __val,
336 _serde::__private::Err(__err) => {
337 return _serde::__private::Err(__err);
338 }
339 },
340 );
341 }
342 1usize => {
343 if _serde::__private::Option::is_some(
344 &m_EventToFreezeBlendValue,
345 ) {
346 return _serde::__private::Err(
347 <__A::Error as _serde::de::Error>::duplicate_field(
348 "EventToFreezeBlendValue",
349 ),
350 );
351 }
352 m_EventToFreezeBlendValue = _serde::__private::Some(
353 match __A::next_value::<hkbEventProperty>(&mut __map) {
354 _serde::__private::Ok(__val) => __val,
355 _serde::__private::Err(__err) => {
356 return _serde::__private::Err(__err);
357 }
358 },
359 );
360 }
361 2usize => {
362 if _serde::__private::Option::is_some(
363 &m_EventToCrossBlend,
364 ) {
365 return _serde::__private::Err(
366 <__A::Error as _serde::de::Error>::duplicate_field(
367 "EventToCrossBlend",
368 ),
369 );
370 }
371 m_EventToCrossBlend = _serde::__private::Some(
372 match __A::next_value::<hkbEventProperty>(&mut __map) {
373 _serde::__private::Ok(__val) => __val,
374 _serde::__private::Err(__err) => {
375 return _serde::__private::Err(__err);
376 }
377 },
378 );
379 }
380 3usize => {
381 if _serde::__private::Option::is_some(&m_fBlendParameter) {
382 return _serde::__private::Err(
383 <__A::Error as _serde::de::Error>::duplicate_field(
384 "fBlendParameter",
385 ),
386 );
387 }
388 m_fBlendParameter = _serde::__private::Some(
389 match __A::next_value::<f32>(&mut __map) {
390 _serde::__private::Ok(__val) => __val,
391 _serde::__private::Err(__err) => {
392 return _serde::__private::Err(__err);
393 }
394 },
395 );
396 }
397 4usize => {
398 if _serde::__private::Option::is_some(
399 &m_fTransitionDuration,
400 ) {
401 return _serde::__private::Err(
402 <__A::Error as _serde::de::Error>::duplicate_field(
403 "fTransitionDuration",
404 ),
405 );
406 }
407 m_fTransitionDuration = _serde::__private::Some(
408 match __A::next_value::<f32>(&mut __map) {
409 _serde::__private::Ok(__val) => __val,
410 _serde::__private::Err(__err) => {
411 return _serde::__private::Err(__err);
412 }
413 },
414 );
415 }
416 5usize => {
417 if _serde::__private::Option::is_some(&m_eBlendCurve) {
418 return _serde::__private::Err(
419 <__A::Error as _serde::de::Error>::duplicate_field(
420 "eBlendCurve",
421 ),
422 );
423 }
424 m_eBlendCurve = _serde::__private::Some(
425 match __A::next_value::<BlendCurve>(&mut __map) {
426 _serde::__private::Ok(__val) => __val,
427 _serde::__private::Err(__err) => {
428 return _serde::__private::Err(__err);
429 }
430 },
431 );
432 }
433 6usize => {
434 if _serde::__private::Option::is_some(
435 &m_pTransitionBlenderGenerator,
436 ) {
437 return _serde::__private::Err(
438 <__A::Error as _serde::de::Error>::duplicate_field(
439 "pTransitionBlenderGenerator",
440 ),
441 );
442 }
443 __A::pad(&mut __map, 3usize, 15usize)?;
444 m_pTransitionBlenderGenerator = _serde::__private::Some(
445 match __A::next_value::<Pointer>(&mut __map) {
446 _serde::__private::Ok(__val) => __val,
447 _serde::__private::Err(__err) => {
448 return _serde::__private::Err(__err);
449 }
450 },
451 );
452 }
453 7usize => {
454 if _serde::__private::Option::is_some(
455 &m_pTransitionEffect,
456 ) {
457 return _serde::__private::Err(
458 <__A::Error as _serde::de::Error>::duplicate_field(
459 "pTransitionEffect",
460 ),
461 );
462 }
463 __A::pad(&mut __map, 12usize, 8usize)?;
464 m_pTransitionEffect = _serde::__private::Some(
465 match __A::next_value::<Pointer>(&mut __map) {
466 _serde::__private::Ok(__val) => __val,
467 _serde::__private::Err(__err) => {
468 return _serde::__private::Err(__err);
469 }
470 },
471 );
472 }
473 8usize => {
474 if _serde::__private::Option::is_some(&m_currentMode) {
475 return _serde::__private::Err(
476 <__A::Error as _serde::de::Error>::duplicate_field(
477 "currentMode",
478 ),
479 );
480 }
481 m_currentMode = _serde::__private::Some(
482 match __A::next_value::<i8>(&mut __map) {
483 _serde::__private::Ok(__val) => __val,
484 _serde::__private::Err(__err) => {
485 return _serde::__private::Err(__err);
486 }
487 },
488 );
489 }
490 _ => {}
491 }
492 }
493 __A::pad(&mut __map, 11usize, 7usize)?;
494 let m_pBlenderGenerator = match m_pBlenderGenerator {
495 _serde::__private::Some(__field) => __field,
496 _serde::__private::None => {
497 return _serde::__private::Err(
498 <__A::Error as _serde::de::Error>::missing_field(
499 "pBlenderGenerator",
500 ),
501 );
502 }
503 };
504 let m_EventToFreezeBlendValue = match m_EventToFreezeBlendValue {
505 _serde::__private::Some(__field) => __field,
506 _serde::__private::None => {
507 return _serde::__private::Err(
508 <__A::Error as _serde::de::Error>::missing_field(
509 "EventToFreezeBlendValue",
510 ),
511 );
512 }
513 };
514 let m_EventToCrossBlend = match m_EventToCrossBlend {
515 _serde::__private::Some(__field) => __field,
516 _serde::__private::None => {
517 return _serde::__private::Err(
518 <__A::Error as _serde::de::Error>::missing_field(
519 "EventToCrossBlend",
520 ),
521 );
522 }
523 };
524 let m_fBlendParameter = match m_fBlendParameter {
525 _serde::__private::Some(__field) => __field,
526 _serde::__private::None => {
527 return _serde::__private::Err(
528 <__A::Error as _serde::de::Error>::missing_field(
529 "fBlendParameter",
530 ),
531 );
532 }
533 };
534 let m_fTransitionDuration = match m_fTransitionDuration {
535 _serde::__private::Some(__field) => __field,
536 _serde::__private::None => {
537 return _serde::__private::Err(
538 <__A::Error as _serde::de::Error>::missing_field(
539 "fTransitionDuration",
540 ),
541 );
542 }
543 };
544 let m_eBlendCurve = match m_eBlendCurve {
545 _serde::__private::Some(__field) => __field,
546 _serde::__private::None => {
547 return _serde::__private::Err(
548 <__A::Error as _serde::de::Error>::missing_field(
549 "eBlendCurve",
550 ),
551 );
552 }
553 };
554 let m_pTransitionBlenderGenerator = match m_pTransitionBlenderGenerator {
555 _serde::__private::Some(__field) => __field,
556 _serde::__private::None => {
557 return _serde::__private::Err(
558 <__A::Error as _serde::de::Error>::missing_field(
559 "pTransitionBlenderGenerator",
560 ),
561 );
562 }
563 };
564 let m_pTransitionEffect = match m_pTransitionEffect {
565 _serde::__private::Some(__field) => __field,
566 _serde::__private::None => {
567 return _serde::__private::Err(
568 <__A::Error as _serde::de::Error>::missing_field(
569 "pTransitionEffect",
570 ),
571 );
572 }
573 };
574 let m_currentMode = match m_currentMode {
575 _serde::__private::Some(__field) => __field,
576 _serde::__private::None => {
577 return _serde::__private::Err(
578 <__A::Error as _serde::de::Error>::missing_field(
579 "currentMode",
580 ),
581 );
582 }
583 };
584 _serde::__private::Ok(BSCyclicBlendTransitionGenerator {
585 __ptr,
586 parent,
587 m_pBlenderGenerator,
588 m_EventToFreezeBlendValue,
589 m_EventToCrossBlend,
590 m_fBlendParameter,
591 m_fTransitionDuration,
592 m_eBlendCurve,
593 m_pTransitionBlenderGenerator,
594 m_pTransitionEffect,
595 m_currentMode,
596 })
597 }
598 #[allow(clippy::manual_unwrap_or_default)]
599 fn visit_struct<__A>(
600 self,
601 mut __map: __A,
602 ) -> _serde::__private::Result<Self::Value, __A::Error>
603 where
604 __A: _serde::de::MapAccess<'de>,
605 {
606 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
607 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
608 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
609 let mut m_pBlenderGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
610 let mut m_EventToFreezeBlendValue: _serde::__private::Option<
611 hkbEventProperty,
612 > = _serde::__private::None;
613 let mut m_EventToCrossBlend: _serde::__private::Option<
614 hkbEventProperty,
615 > = _serde::__private::None;
616 let mut m_fBlendParameter: _serde::__private::Option<f32> = _serde::__private::None;
617 let mut m_fTransitionDuration: _serde::__private::Option<f32> = _serde::__private::None;
618 let mut m_eBlendCurve: _serde::__private::Option<BlendCurve> = _serde::__private::None;
619 while let _serde::__private::Some(__key) = {
620 __A::next_key::<__Field>(&mut __map)?
621 } {
622 match __key {
623 __Field::m_variableBindingSet => {
624 #[cfg(
625 any(feature = "strict", feature = "ignore_duplicates")
626 )]
627 if _serde::__private::Option::is_some(
628 &m_variableBindingSet,
629 ) {
630 #[cfg(feature = "ignore_duplicates")]
631 {
632 __A::skip_value(&mut __map)?;
633 continue;
634 }
635 #[cfg(feature = "strict")]
636 return _serde::__private::Err(
637 <__A::Error as _serde::de::Error>::duplicate_field(
638 "variableBindingSet",
639 ),
640 );
641 }
642 m_variableBindingSet = _serde::__private::Some(
643 match __A::next_value::<Pointer>(&mut __map) {
644 _serde::__private::Ok(__val) => __val,
645 _serde::__private::Err(__err) => {
646 return _serde::__private::Err(__err);
647 }
648 },
649 );
650 }
651 __Field::m_userData => {
652 #[cfg(
653 any(feature = "strict", feature = "ignore_duplicates")
654 )]
655 if _serde::__private::Option::is_some(&m_userData) {
656 #[cfg(feature = "ignore_duplicates")]
657 {
658 __A::skip_value(&mut __map)?;
659 continue;
660 }
661 #[cfg(feature = "strict")]
662 return _serde::__private::Err(
663 <__A::Error as _serde::de::Error>::duplicate_field(
664 "userData",
665 ),
666 );
667 }
668 m_userData = _serde::__private::Some(
669 match __A::next_value::<Ulong>(&mut __map) {
670 _serde::__private::Ok(__val) => __val,
671 _serde::__private::Err(__err) => {
672 return _serde::__private::Err(__err);
673 }
674 },
675 );
676 }
677 __Field::m_name => {
678 #[cfg(
679 any(feature = "strict", feature = "ignore_duplicates")
680 )]
681 if _serde::__private::Option::is_some(&m_name) {
682 #[cfg(feature = "ignore_duplicates")]
683 {
684 __A::skip_value(&mut __map)?;
685 continue;
686 }
687 #[cfg(feature = "strict")]
688 return _serde::__private::Err(
689 <__A::Error as _serde::de::Error>::duplicate_field("name"),
690 );
691 }
692 m_name = _serde::__private::Some(
693 match __A::next_value::<StringPtr<'de>>(&mut __map) {
694 _serde::__private::Ok(__val) => __val,
695 _serde::__private::Err(__err) => {
696 return _serde::__private::Err(__err);
697 }
698 },
699 );
700 }
701 __Field::m_pBlenderGenerator => {
702 #[cfg(
703 any(feature = "strict", feature = "ignore_duplicates")
704 )]
705 if _serde::__private::Option::is_some(
706 &m_pBlenderGenerator,
707 ) {
708 #[cfg(feature = "ignore_duplicates")]
709 {
710 __A::skip_value(&mut __map)?;
711 continue;
712 }
713 #[cfg(feature = "strict")]
714 return _serde::__private::Err(
715 <__A::Error as _serde::de::Error>::duplicate_field(
716 "pBlenderGenerator",
717 ),
718 );
719 }
720 m_pBlenderGenerator = _serde::__private::Some(
721 match __A::next_value::<Pointer>(&mut __map) {
722 _serde::__private::Ok(__val) => __val,
723 _serde::__private::Err(__err) => {
724 return _serde::__private::Err(__err);
725 }
726 },
727 );
728 }
729 __Field::m_EventToFreezeBlendValue => {
730 #[cfg(
731 any(feature = "strict", feature = "ignore_duplicates")
732 )]
733 if _serde::__private::Option::is_some(
734 &m_EventToFreezeBlendValue,
735 ) {
736 #[cfg(feature = "ignore_duplicates")]
737 {
738 __A::skip_value(&mut __map)?;
739 continue;
740 }
741 #[cfg(feature = "strict")]
742 return _serde::__private::Err(
743 <__A::Error as _serde::de::Error>::duplicate_field(
744 "EventToFreezeBlendValue",
745 ),
746 );
747 }
748 m_EventToFreezeBlendValue = _serde::__private::Some(
749 match __A::next_value::<hkbEventProperty>(&mut __map) {
750 _serde::__private::Ok(__val) => __val,
751 _serde::__private::Err(__err) => {
752 return _serde::__private::Err(__err);
753 }
754 },
755 );
756 }
757 __Field::m_EventToCrossBlend => {
758 #[cfg(
759 any(feature = "strict", feature = "ignore_duplicates")
760 )]
761 if _serde::__private::Option::is_some(
762 &m_EventToCrossBlend,
763 ) {
764 #[cfg(feature = "ignore_duplicates")]
765 {
766 __A::skip_value(&mut __map)?;
767 continue;
768 }
769 #[cfg(feature = "strict")]
770 return _serde::__private::Err(
771 <__A::Error as _serde::de::Error>::duplicate_field(
772 "EventToCrossBlend",
773 ),
774 );
775 }
776 m_EventToCrossBlend = _serde::__private::Some(
777 match __A::next_value::<hkbEventProperty>(&mut __map) {
778 _serde::__private::Ok(__val) => __val,
779 _serde::__private::Err(__err) => {
780 return _serde::__private::Err(__err);
781 }
782 },
783 );
784 }
785 __Field::m_fBlendParameter => {
786 #[cfg(
787 any(feature = "strict", feature = "ignore_duplicates")
788 )]
789 if _serde::__private::Option::is_some(&m_fBlendParameter) {
790 #[cfg(feature = "ignore_duplicates")]
791 {
792 __A::skip_value(&mut __map)?;
793 continue;
794 }
795 #[cfg(feature = "strict")]
796 return _serde::__private::Err(
797 <__A::Error as _serde::de::Error>::duplicate_field(
798 "fBlendParameter",
799 ),
800 );
801 }
802 m_fBlendParameter = _serde::__private::Some(
803 match __A::next_value::<f32>(&mut __map) {
804 _serde::__private::Ok(__val) => __val,
805 _serde::__private::Err(__err) => {
806 return _serde::__private::Err(__err);
807 }
808 },
809 );
810 }
811 __Field::m_fTransitionDuration => {
812 #[cfg(
813 any(feature = "strict", feature = "ignore_duplicates")
814 )]
815 if _serde::__private::Option::is_some(
816 &m_fTransitionDuration,
817 ) {
818 #[cfg(feature = "ignore_duplicates")]
819 {
820 __A::skip_value(&mut __map)?;
821 continue;
822 }
823 #[cfg(feature = "strict")]
824 return _serde::__private::Err(
825 <__A::Error as _serde::de::Error>::duplicate_field(
826 "fTransitionDuration",
827 ),
828 );
829 }
830 m_fTransitionDuration = _serde::__private::Some(
831 match __A::next_value::<f32>(&mut __map) {
832 _serde::__private::Ok(__val) => __val,
833 _serde::__private::Err(__err) => {
834 return _serde::__private::Err(__err);
835 }
836 },
837 );
838 }
839 __Field::m_eBlendCurve => {
840 #[cfg(
841 any(feature = "strict", feature = "ignore_duplicates")
842 )]
843 if _serde::__private::Option::is_some(&m_eBlendCurve) {
844 #[cfg(feature = "ignore_duplicates")]
845 {
846 __A::skip_value(&mut __map)?;
847 continue;
848 }
849 #[cfg(feature = "strict")]
850 return _serde::__private::Err(
851 <__A::Error as _serde::de::Error>::duplicate_field(
852 "eBlendCurve",
853 ),
854 );
855 }
856 m_eBlendCurve = _serde::__private::Some(
857 match __A::next_value::<BlendCurve>(&mut __map) {
858 _serde::__private::Ok(__val) => __val,
859 _serde::__private::Err(__err) => {
860 return _serde::__private::Err(__err);
861 }
862 },
863 );
864 }
865 _ => __A::skip_value(&mut __map)?,
866 }
867 }
868 let m_variableBindingSet = match m_variableBindingSet {
869 _serde::__private::Some(__field) => __field,
870 _serde::__private::None => {
871 #[cfg(feature = "strict")]
872 return _serde::__private::Err(
873 <__A::Error as _serde::de::Error>::missing_field(
874 "variableBindingSet",
875 ),
876 );
877 #[cfg(not(feature = "strict"))] Default::default()
878 }
879 };
880 let m_userData = match m_userData {
881 _serde::__private::Some(__field) => __field,
882 _serde::__private::None => {
883 #[cfg(feature = "strict")]
884 return _serde::__private::Err(
885 <__A::Error as _serde::de::Error>::missing_field("userData"),
886 );
887 #[cfg(not(feature = "strict"))] Default::default()
888 }
889 };
890 let m_name = match m_name {
891 _serde::__private::Some(__field) => __field,
892 _serde::__private::None => {
893 #[cfg(feature = "strict")]
894 return _serde::__private::Err(
895 <__A::Error as _serde::de::Error>::missing_field("name"),
896 );
897 #[cfg(not(feature = "strict"))] Default::default()
898 }
899 };
900 let m_pBlenderGenerator = match m_pBlenderGenerator {
901 _serde::__private::Some(__field) => __field,
902 _serde::__private::None => {
903 #[cfg(feature = "strict")]
904 return _serde::__private::Err(
905 <__A::Error as _serde::de::Error>::missing_field(
906 "pBlenderGenerator",
907 ),
908 );
909 #[cfg(not(feature = "strict"))] Default::default()
910 }
911 };
912 let m_EventToFreezeBlendValue = match m_EventToFreezeBlendValue {
913 _serde::__private::Some(__field) => __field,
914 _serde::__private::None => {
915 #[cfg(feature = "strict")]
916 return _serde::__private::Err(
917 <__A::Error as _serde::de::Error>::missing_field(
918 "EventToFreezeBlendValue",
919 ),
920 );
921 #[cfg(not(feature = "strict"))] Default::default()
922 }
923 };
924 let m_EventToCrossBlend = match m_EventToCrossBlend {
925 _serde::__private::Some(__field) => __field,
926 _serde::__private::None => {
927 #[cfg(feature = "strict")]
928 return _serde::__private::Err(
929 <__A::Error as _serde::de::Error>::missing_field(
930 "EventToCrossBlend",
931 ),
932 );
933 #[cfg(not(feature = "strict"))] Default::default()
934 }
935 };
936 let m_fBlendParameter = match m_fBlendParameter {
937 _serde::__private::Some(__field) => __field,
938 _serde::__private::None => {
939 #[cfg(feature = "strict")]
940 return _serde::__private::Err(
941 <__A::Error as _serde::de::Error>::missing_field(
942 "fBlendParameter",
943 ),
944 );
945 #[cfg(not(feature = "strict"))] Default::default()
946 }
947 };
948 let m_fTransitionDuration = match m_fTransitionDuration {
949 _serde::__private::Some(__field) => __field,
950 _serde::__private::None => {
951 #[cfg(feature = "strict")]
952 return _serde::__private::Err(
953 <__A::Error as _serde::de::Error>::missing_field(
954 "fTransitionDuration",
955 ),
956 );
957 #[cfg(not(feature = "strict"))] Default::default()
958 }
959 };
960 let m_eBlendCurve = match m_eBlendCurve {
961 _serde::__private::Some(__field) => __field,
962 _serde::__private::None => {
963 #[cfg(feature = "strict")]
964 return _serde::__private::Err(
965 <__A::Error as _serde::de::Error>::missing_field(
966 "eBlendCurve",
967 ),
968 );
969 #[cfg(not(feature = "strict"))] Default::default()
970 }
971 };
972 let __ptr = None;
973 let parent = hkBaseObject { __ptr };
974 let parent = hkReferencedObject {
975 __ptr,
976 parent,
977 ..Default::default()
978 };
979 let parent = hkbBindable {
980 __ptr,
981 parent,
982 m_variableBindingSet,
983 ..Default::default()
984 };
985 let parent = hkbNode {
986 __ptr,
987 parent,
988 m_userData,
989 m_name,
990 ..Default::default()
991 };
992 let parent = hkbGenerator { __ptr, parent };
993 let __ptr = __A::class_ptr(&mut __map);
994 _serde::__private::Ok(BSCyclicBlendTransitionGenerator {
995 __ptr,
996 parent,
997 m_pBlenderGenerator,
998 m_EventToFreezeBlendValue,
999 m_EventToCrossBlend,
1000 m_fBlendParameter,
1001 m_fTransitionDuration,
1002 m_eBlendCurve,
1003 ..Default::default()
1004 })
1005 }
1006 }
1007 const FIELDS: &[&str] = &[
1008 "pBlenderGenerator",
1009 "EventToFreezeBlendValue",
1010 "EventToCrossBlend",
1011 "fBlendParameter",
1012 "fTransitionDuration",
1013 "eBlendCurve",
1014 "pTransitionBlenderGenerator",
1015 "pTransitionEffect",
1016 "currentMode",
1017 ];
1018 _serde::Deserializer::deserialize_struct(
1019 deserializer,
1020 "BSCyclicBlendTransitionGenerator",
1021 FIELDS,
1022 __BSCyclicBlendTransitionGeneratorVisitor {
1023 marker: _serde::__private::PhantomData::<
1024 BSCyclicBlendTransitionGenerator,
1025 >,
1026 lifetime: _serde::__private::PhantomData,
1027 },
1028 )
1029 }
1030 }
1031};