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