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 hkbGeneratorTransitionEffect<'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: hkbTransitionEffect<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "transitionGenerator"))]
36 #[cfg_attr(feature = "serde", serde(rename = "transitionGenerator"))]
37 pub m_transitionGenerator: Pointer,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "blendInDuration"))]
43 #[cfg_attr(feature = "serde", serde(rename = "blendInDuration"))]
44 pub m_blendInDuration: f32,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "blendOutDuration"))]
50 #[cfg_attr(feature = "serde", serde(rename = "blendOutDuration"))]
51 pub m_blendOutDuration: f32,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "syncToGeneratorStartTime"))]
57 #[cfg_attr(feature = "serde", serde(rename = "syncToGeneratorStartTime"))]
58 pub m_syncToGeneratorStartTime: bool,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "fromGenerator"))]
65 #[cfg_attr(feature = "serde", serde(rename = "fromGenerator"))]
66 pub m_fromGenerator: Pointer,
67 #[cfg_attr(feature = "json_schema", schemars(rename = "toGenerator"))]
73 #[cfg_attr(feature = "serde", serde(rename = "toGenerator"))]
74 pub m_toGenerator: Pointer,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "timeInTransition"))]
81 #[cfg_attr(feature = "serde", serde(rename = "timeInTransition"))]
82 pub m_timeInTransition: f32,
83 #[cfg_attr(feature = "json_schema", schemars(rename = "duration"))]
89 #[cfg_attr(feature = "serde", serde(rename = "duration"))]
90 pub m_duration: f32,
91 #[cfg_attr(feature = "json_schema", schemars(rename = "effectiveBlendInDuration"))]
97 #[cfg_attr(feature = "serde", serde(rename = "effectiveBlendInDuration"))]
98 pub m_effectiveBlendInDuration: f32,
99 #[cfg_attr(feature = "json_schema", schemars(rename = "effectiveBlendOutDuration"))]
105 #[cfg_attr(feature = "serde", serde(rename = "effectiveBlendOutDuration"))]
106 pub m_effectiveBlendOutDuration: f32,
107 #[cfg_attr(feature = "json_schema", schemars(rename = "toGeneratorState"))]
113 #[cfg_attr(feature = "serde", serde(rename = "toGeneratorState"))]
114 pub m_toGeneratorState: i8,
115 #[cfg_attr(feature = "json_schema", schemars(rename = "echoTransitionGenerator"))]
121 #[cfg_attr(feature = "serde", serde(rename = "echoTransitionGenerator"))]
122 pub m_echoTransitionGenerator: bool,
123 #[cfg_attr(feature = "json_schema", schemars(rename = "echoToGenerator"))]
129 #[cfg_attr(feature = "serde", serde(rename = "echoToGenerator"))]
130 pub m_echoToGenerator: bool,
131 #[cfg_attr(feature = "json_schema", schemars(rename = "justActivated"))]
137 #[cfg_attr(feature = "serde", serde(rename = "justActivated"))]
138 pub m_justActivated: bool,
139 #[cfg_attr(feature = "json_schema", schemars(rename = "updateActiveNodes"))]
145 #[cfg_attr(feature = "serde", serde(rename = "updateActiveNodes"))]
146 pub m_updateActiveNodes: bool,
147 #[cfg_attr(feature = "json_schema", schemars(rename = "stage"))]
153 #[cfg_attr(feature = "serde", serde(rename = "stage"))]
154 pub m_stage: i8,
155}
156const _: () = {
157 use havok_serde as _serde;
158 impl<'a> _serde::HavokClass for hkbGeneratorTransitionEffect<'a> {
159 #[inline]
160 fn name(&self) -> &'static str {
161 "hkbGeneratorTransitionEffect"
162 }
163 #[inline]
164 fn signature(&self) -> _serde::__private::Signature {
165 _serde::__private::Signature::new(0x5f771b12)
166 }
167 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
168 fn deps_indexes(&self) -> Vec<usize> {
169 let mut v = Vec::new();
170 v.push(self.parent.parent.parent.parent.m_variableBindingSet.get());
171 v.push(self.m_transitionGenerator.get());
172 v.push(self.m_fromGenerator.get());
173 v.push(self.m_toGenerator.get());
174 v
175 }
176 }
177 impl<'a> _serde::Serialize for hkbGeneratorTransitionEffect<'a> {
178 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
179 where
180 S: _serde::ser::Serializer,
181 {
182 let class_meta = self
183 .__ptr
184 .map(|name| (name, _serde::__private::Signature::new(0x5f771b12)));
185 let mut serializer = __serializer
186 .serialize_struct(
187 "hkbGeneratorTransitionEffect",
188 class_meta,
189 (92u64, 144u64),
190 )?;
191 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
192 serializer
193 .skip_field(
194 "memSizeAndFlags",
195 &self.parent.parent.parent.parent.parent.m_memSizeAndFlags,
196 )?;
197 serializer
198 .skip_field(
199 "referenceCount",
200 &self.parent.parent.parent.parent.parent.m_referenceCount,
201 )?;
202 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
203 serializer
204 .serialize_field(
205 "variableBindingSet",
206 &self.parent.parent.parent.parent.m_variableBindingSet,
207 )?;
208 serializer
209 .skip_array_field(
210 "cachedBindables",
211 &self.parent.parent.parent.parent.m_cachedBindables,
212 TypeSize::NonPtr,
213 )?;
214 serializer
215 .skip_field(
216 "areBindablesCached",
217 &self.parent.parent.parent.parent.m_areBindablesCached,
218 )?;
219 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
220 serializer
221 .serialize_field("userData", &self.parent.parent.parent.m_userData)?;
222 serializer.serialize_field("name", &self.parent.parent.parent.m_name)?;
223 serializer.skip_field("id", &self.parent.parent.parent.m_id)?;
224 serializer
225 .skip_field("cloneState", &self.parent.parent.parent.m_cloneState)?;
226 serializer
227 .skip_fixed_array_field(
228 "padNode",
229 self.parent.parent.parent.m_padNode.as_slice(),
230 TypeSize::NonPtr,
231 )?;
232 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
233 serializer
234 .serialize_field(
235 "selfTransitionMode",
236 &self.parent.m_selfTransitionMode,
237 )?;
238 serializer.serialize_field("eventMode", &self.parent.m_eventMode)?;
239 serializer.skip_field("defaultEventMode", &self.parent.m_defaultEventMode)?;
240 serializer.pad_field([0u8; 1usize].as_slice(), [0u8; 5usize].as_slice())?;
241 serializer
242 .serialize_field("transitionGenerator", &self.m_transitionGenerator)?;
243 serializer.serialize_field("blendInDuration", &self.m_blendInDuration)?;
244 serializer.serialize_field("blendOutDuration", &self.m_blendOutDuration)?;
245 serializer
246 .serialize_field(
247 "syncToGeneratorStartTime",
248 &self.m_syncToGeneratorStartTime,
249 )?;
250 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
251 serializer.skip_field("fromGenerator", &self.m_fromGenerator)?;
252 serializer.skip_field("toGenerator", &self.m_toGenerator)?;
253 serializer.skip_field("timeInTransition", &self.m_timeInTransition)?;
254 serializer.skip_field("duration", &self.m_duration)?;
255 serializer
256 .skip_field(
257 "effectiveBlendInDuration",
258 &self.m_effectiveBlendInDuration,
259 )?;
260 serializer
261 .skip_field(
262 "effectiveBlendOutDuration",
263 &self.m_effectiveBlendOutDuration,
264 )?;
265 serializer.skip_field("toGeneratorState", &self.m_toGeneratorState)?;
266 serializer
267 .skip_field("echoTransitionGenerator", &self.m_echoTransitionGenerator)?;
268 serializer.skip_field("echoToGenerator", &self.m_echoToGenerator)?;
269 serializer.skip_field("justActivated", &self.m_justActivated)?;
270 serializer.skip_field("updateActiveNodes", &self.m_updateActiveNodes)?;
271 serializer.skip_field("stage", &self.m_stage)?;
272 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
273 serializer.end()
274 }
275 }
276};
277#[doc(hidden)]
278#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
279const _: () = {
280 use havok_serde as _serde;
281 #[automatically_derived]
282 impl<'de> _serde::Deserialize<'de> for hkbGeneratorTransitionEffect<'de> {
283 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
284 where
285 __D: _serde::Deserializer<'de>,
286 {
287 #[allow(non_camel_case_types)]
288 enum __Field {
289 m_variableBindingSet,
290 m_userData,
291 m_name,
292 m_selfTransitionMode,
293 m_eventMode,
294 m_transitionGenerator,
295 m_blendInDuration,
296 m_blendOutDuration,
297 m_syncToGeneratorStartTime,
298 __ignore,
299 }
300 struct __FieldVisitor;
301 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
302 type Value = __Field;
303 fn expecting(
304 &self,
305 __formatter: &mut core::fmt::Formatter,
306 ) -> core::fmt::Result {
307 core::fmt::Formatter::write_str(__formatter, "field identifier")
308 }
309 #[allow(clippy::match_single_binding)]
311 #[allow(clippy::reversed_empty_ranges)]
312 #[allow(clippy::single_match)]
313 fn visit_key<__E>(
314 self,
315 __value: &str,
316 ) -> core::result::Result<Self::Value, __E>
317 where
318 __E: _serde::de::Error,
319 {
320 match __value {
321 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
322 "userData" => Ok(__Field::m_userData),
323 "name" => Ok(__Field::m_name),
324 "selfTransitionMode" => Ok(__Field::m_selfTransitionMode),
325 "eventMode" => Ok(__Field::m_eventMode),
326 "transitionGenerator" => Ok(__Field::m_transitionGenerator),
327 "blendInDuration" => Ok(__Field::m_blendInDuration),
328 "blendOutDuration" => Ok(__Field::m_blendOutDuration),
329 "syncToGeneratorStartTime" => {
330 Ok(__Field::m_syncToGeneratorStartTime)
331 }
332 _ => Ok(__Field::__ignore),
333 }
334 }
335 }
336 impl<'de> _serde::Deserialize<'de> for __Field {
337 #[inline]
338 fn deserialize<__D>(
339 __deserializer: __D,
340 ) -> core::result::Result<Self, __D::Error>
341 where
342 __D: _serde::Deserializer<'de>,
343 {
344 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
345 }
346 }
347 struct __hkbGeneratorTransitionEffectVisitor<'de> {
348 marker: _serde::__private::PhantomData<
349 hkbGeneratorTransitionEffect<'de>,
350 >,
351 lifetime: _serde::__private::PhantomData<&'de ()>,
352 }
353 #[allow(clippy::match_single_binding)]
354 #[allow(clippy::reversed_empty_ranges)]
355 #[allow(clippy::single_match)]
356 impl<'de> _serde::de::Visitor<'de>
357 for __hkbGeneratorTransitionEffectVisitor<'de> {
358 type Value = hkbGeneratorTransitionEffect<'de>;
359 fn expecting(
360 &self,
361 __formatter: &mut core::fmt::Formatter,
362 ) -> core::fmt::Result {
363 core::fmt::Formatter::write_str(
364 __formatter,
365 "struct hkbGeneratorTransitionEffect",
366 )
367 }
368 fn visit_struct_for_bytes<__A>(
369 self,
370 mut __map: __A,
371 ) -> _serde::__private::Result<Self::Value, __A::Error>
372 where
373 __A: _serde::de::MapAccess<'de>,
374 {
375 let __ptr = __A::class_ptr(&mut __map);
376 let parent = __A::parent_value(&mut __map)?;
377 let mut m_transitionGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
378 let mut m_blendInDuration: _serde::__private::Option<f32> = _serde::__private::None;
379 let mut m_blendOutDuration: _serde::__private::Option<f32> = _serde::__private::None;
380 let mut m_syncToGeneratorStartTime: _serde::__private::Option<
381 bool,
382 > = _serde::__private::None;
383 let mut m_fromGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
384 let mut m_toGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
385 let mut m_timeInTransition: _serde::__private::Option<f32> = _serde::__private::None;
386 let mut m_duration: _serde::__private::Option<f32> = _serde::__private::None;
387 let mut m_effectiveBlendInDuration: _serde::__private::Option<f32> = _serde::__private::None;
388 let mut m_effectiveBlendOutDuration: _serde::__private::Option<
389 f32,
390 > = _serde::__private::None;
391 let mut m_toGeneratorState: _serde::__private::Option<i8> = _serde::__private::None;
392 let mut m_echoTransitionGenerator: _serde::__private::Option<bool> = _serde::__private::None;
393 let mut m_echoToGenerator: _serde::__private::Option<bool> = _serde::__private::None;
394 let mut m_justActivated: _serde::__private::Option<bool> = _serde::__private::None;
395 let mut m_updateActiveNodes: _serde::__private::Option<bool> = _serde::__private::None;
396 let mut m_stage: _serde::__private::Option<i8> = _serde::__private::None;
397 for i in 0..16usize {
398 match i {
399 0usize => {
400 if _serde::__private::Option::is_some(
401 &m_transitionGenerator,
402 ) {
403 return _serde::__private::Err(
404 <__A::Error as _serde::de::Error>::duplicate_field(
405 "transitionGenerator",
406 ),
407 );
408 }
409 m_transitionGenerator = _serde::__private::Some(
410 match __A::next_value::<Pointer>(&mut __map) {
411 _serde::__private::Ok(__val) => __val,
412 _serde::__private::Err(__err) => {
413 return _serde::__private::Err(__err);
414 }
415 },
416 );
417 }
418 1usize => {
419 if _serde::__private::Option::is_some(&m_blendInDuration) {
420 return _serde::__private::Err(
421 <__A::Error as _serde::de::Error>::duplicate_field(
422 "blendInDuration",
423 ),
424 );
425 }
426 m_blendInDuration = _serde::__private::Some(
427 match __A::next_value::<f32>(&mut __map) {
428 _serde::__private::Ok(__val) => __val,
429 _serde::__private::Err(__err) => {
430 return _serde::__private::Err(__err);
431 }
432 },
433 );
434 }
435 2usize => {
436 if _serde::__private::Option::is_some(&m_blendOutDuration) {
437 return _serde::__private::Err(
438 <__A::Error as _serde::de::Error>::duplicate_field(
439 "blendOutDuration",
440 ),
441 );
442 }
443 m_blendOutDuration = _serde::__private::Some(
444 match __A::next_value::<f32>(&mut __map) {
445 _serde::__private::Ok(__val) => __val,
446 _serde::__private::Err(__err) => {
447 return _serde::__private::Err(__err);
448 }
449 },
450 );
451 }
452 3usize => {
453 if _serde::__private::Option::is_some(
454 &m_syncToGeneratorStartTime,
455 ) {
456 return _serde::__private::Err(
457 <__A::Error as _serde::de::Error>::duplicate_field(
458 "syncToGeneratorStartTime",
459 ),
460 );
461 }
462 m_syncToGeneratorStartTime = _serde::__private::Some(
463 match __A::next_value::<bool>(&mut __map) {
464 _serde::__private::Ok(__val) => __val,
465 _serde::__private::Err(__err) => {
466 return _serde::__private::Err(__err);
467 }
468 },
469 );
470 }
471 4usize => {
472 if _serde::__private::Option::is_some(&m_fromGenerator) {
473 return _serde::__private::Err(
474 <__A::Error as _serde::de::Error>::duplicate_field(
475 "fromGenerator",
476 ),
477 );
478 }
479 __A::pad(&mut __map, 3usize, 7usize)?;
480 m_fromGenerator = _serde::__private::Some(
481 match __A::next_value::<Pointer>(&mut __map) {
482 _serde::__private::Ok(__val) => __val,
483 _serde::__private::Err(__err) => {
484 return _serde::__private::Err(__err);
485 }
486 },
487 );
488 }
489 5usize => {
490 if _serde::__private::Option::is_some(&m_toGenerator) {
491 return _serde::__private::Err(
492 <__A::Error as _serde::de::Error>::duplicate_field(
493 "toGenerator",
494 ),
495 );
496 }
497 m_toGenerator = _serde::__private::Some(
498 match __A::next_value::<Pointer>(&mut __map) {
499 _serde::__private::Ok(__val) => __val,
500 _serde::__private::Err(__err) => {
501 return _serde::__private::Err(__err);
502 }
503 },
504 );
505 }
506 6usize => {
507 if _serde::__private::Option::is_some(&m_timeInTransition) {
508 return _serde::__private::Err(
509 <__A::Error as _serde::de::Error>::duplicate_field(
510 "timeInTransition",
511 ),
512 );
513 }
514 m_timeInTransition = _serde::__private::Some(
515 match __A::next_value::<f32>(&mut __map) {
516 _serde::__private::Ok(__val) => __val,
517 _serde::__private::Err(__err) => {
518 return _serde::__private::Err(__err);
519 }
520 },
521 );
522 }
523 7usize => {
524 if _serde::__private::Option::is_some(&m_duration) {
525 return _serde::__private::Err(
526 <__A::Error as _serde::de::Error>::duplicate_field(
527 "duration",
528 ),
529 );
530 }
531 m_duration = _serde::__private::Some(
532 match __A::next_value::<f32>(&mut __map) {
533 _serde::__private::Ok(__val) => __val,
534 _serde::__private::Err(__err) => {
535 return _serde::__private::Err(__err);
536 }
537 },
538 );
539 }
540 8usize => {
541 if _serde::__private::Option::is_some(
542 &m_effectiveBlendInDuration,
543 ) {
544 return _serde::__private::Err(
545 <__A::Error as _serde::de::Error>::duplicate_field(
546 "effectiveBlendInDuration",
547 ),
548 );
549 }
550 m_effectiveBlendInDuration = _serde::__private::Some(
551 match __A::next_value::<f32>(&mut __map) {
552 _serde::__private::Ok(__val) => __val,
553 _serde::__private::Err(__err) => {
554 return _serde::__private::Err(__err);
555 }
556 },
557 );
558 }
559 9usize => {
560 if _serde::__private::Option::is_some(
561 &m_effectiveBlendOutDuration,
562 ) {
563 return _serde::__private::Err(
564 <__A::Error as _serde::de::Error>::duplicate_field(
565 "effectiveBlendOutDuration",
566 ),
567 );
568 }
569 m_effectiveBlendOutDuration = _serde::__private::Some(
570 match __A::next_value::<f32>(&mut __map) {
571 _serde::__private::Ok(__val) => __val,
572 _serde::__private::Err(__err) => {
573 return _serde::__private::Err(__err);
574 }
575 },
576 );
577 }
578 10usize => {
579 if _serde::__private::Option::is_some(&m_toGeneratorState) {
580 return _serde::__private::Err(
581 <__A::Error as _serde::de::Error>::duplicate_field(
582 "toGeneratorState",
583 ),
584 );
585 }
586 m_toGeneratorState = _serde::__private::Some(
587 match __A::next_value::<i8>(&mut __map) {
588 _serde::__private::Ok(__val) => __val,
589 _serde::__private::Err(__err) => {
590 return _serde::__private::Err(__err);
591 }
592 },
593 );
594 }
595 11usize => {
596 if _serde::__private::Option::is_some(
597 &m_echoTransitionGenerator,
598 ) {
599 return _serde::__private::Err(
600 <__A::Error as _serde::de::Error>::duplicate_field(
601 "echoTransitionGenerator",
602 ),
603 );
604 }
605 m_echoTransitionGenerator = _serde::__private::Some(
606 match __A::next_value::<bool>(&mut __map) {
607 _serde::__private::Ok(__val) => __val,
608 _serde::__private::Err(__err) => {
609 return _serde::__private::Err(__err);
610 }
611 },
612 );
613 }
614 12usize => {
615 if _serde::__private::Option::is_some(&m_echoToGenerator) {
616 return _serde::__private::Err(
617 <__A::Error as _serde::de::Error>::duplicate_field(
618 "echoToGenerator",
619 ),
620 );
621 }
622 m_echoToGenerator = _serde::__private::Some(
623 match __A::next_value::<bool>(&mut __map) {
624 _serde::__private::Ok(__val) => __val,
625 _serde::__private::Err(__err) => {
626 return _serde::__private::Err(__err);
627 }
628 },
629 );
630 }
631 13usize => {
632 if _serde::__private::Option::is_some(&m_justActivated) {
633 return _serde::__private::Err(
634 <__A::Error as _serde::de::Error>::duplicate_field(
635 "justActivated",
636 ),
637 );
638 }
639 m_justActivated = _serde::__private::Some(
640 match __A::next_value::<bool>(&mut __map) {
641 _serde::__private::Ok(__val) => __val,
642 _serde::__private::Err(__err) => {
643 return _serde::__private::Err(__err);
644 }
645 },
646 );
647 }
648 14usize => {
649 if _serde::__private::Option::is_some(
650 &m_updateActiveNodes,
651 ) {
652 return _serde::__private::Err(
653 <__A::Error as _serde::de::Error>::duplicate_field(
654 "updateActiveNodes",
655 ),
656 );
657 }
658 m_updateActiveNodes = _serde::__private::Some(
659 match __A::next_value::<bool>(&mut __map) {
660 _serde::__private::Ok(__val) => __val,
661 _serde::__private::Err(__err) => {
662 return _serde::__private::Err(__err);
663 }
664 },
665 );
666 }
667 15usize => {
668 if _serde::__private::Option::is_some(&m_stage) {
669 return _serde::__private::Err(
670 <__A::Error as _serde::de::Error>::duplicate_field("stage"),
671 );
672 }
673 m_stage = _serde::__private::Some(
674 match __A::next_value::<i8>(&mut __map) {
675 _serde::__private::Ok(__val) => __val,
676 _serde::__private::Err(__err) => {
677 return _serde::__private::Err(__err);
678 }
679 },
680 );
681 }
682 _ => {}
683 }
684 }
685 __A::pad(&mut __map, 2usize, 2usize)?;
686 let m_transitionGenerator = match m_transitionGenerator {
687 _serde::__private::Some(__field) => __field,
688 _serde::__private::None => {
689 return _serde::__private::Err(
690 <__A::Error as _serde::de::Error>::missing_field(
691 "transitionGenerator",
692 ),
693 );
694 }
695 };
696 let m_blendInDuration = match m_blendInDuration {
697 _serde::__private::Some(__field) => __field,
698 _serde::__private::None => {
699 return _serde::__private::Err(
700 <__A::Error as _serde::de::Error>::missing_field(
701 "blendInDuration",
702 ),
703 );
704 }
705 };
706 let m_blendOutDuration = match m_blendOutDuration {
707 _serde::__private::Some(__field) => __field,
708 _serde::__private::None => {
709 return _serde::__private::Err(
710 <__A::Error as _serde::de::Error>::missing_field(
711 "blendOutDuration",
712 ),
713 );
714 }
715 };
716 let m_syncToGeneratorStartTime = match m_syncToGeneratorStartTime {
717 _serde::__private::Some(__field) => __field,
718 _serde::__private::None => {
719 return _serde::__private::Err(
720 <__A::Error as _serde::de::Error>::missing_field(
721 "syncToGeneratorStartTime",
722 ),
723 );
724 }
725 };
726 let m_fromGenerator = match m_fromGenerator {
727 _serde::__private::Some(__field) => __field,
728 _serde::__private::None => {
729 return _serde::__private::Err(
730 <__A::Error as _serde::de::Error>::missing_field(
731 "fromGenerator",
732 ),
733 );
734 }
735 };
736 let m_toGenerator = match m_toGenerator {
737 _serde::__private::Some(__field) => __field,
738 _serde::__private::None => {
739 return _serde::__private::Err(
740 <__A::Error as _serde::de::Error>::missing_field(
741 "toGenerator",
742 ),
743 );
744 }
745 };
746 let m_timeInTransition = match m_timeInTransition {
747 _serde::__private::Some(__field) => __field,
748 _serde::__private::None => {
749 return _serde::__private::Err(
750 <__A::Error as _serde::de::Error>::missing_field(
751 "timeInTransition",
752 ),
753 );
754 }
755 };
756 let m_duration = match m_duration {
757 _serde::__private::Some(__field) => __field,
758 _serde::__private::None => {
759 return _serde::__private::Err(
760 <__A::Error as _serde::de::Error>::missing_field("duration"),
761 );
762 }
763 };
764 let m_effectiveBlendInDuration = match m_effectiveBlendInDuration {
765 _serde::__private::Some(__field) => __field,
766 _serde::__private::None => {
767 return _serde::__private::Err(
768 <__A::Error as _serde::de::Error>::missing_field(
769 "effectiveBlendInDuration",
770 ),
771 );
772 }
773 };
774 let m_effectiveBlendOutDuration = match m_effectiveBlendOutDuration {
775 _serde::__private::Some(__field) => __field,
776 _serde::__private::None => {
777 return _serde::__private::Err(
778 <__A::Error as _serde::de::Error>::missing_field(
779 "effectiveBlendOutDuration",
780 ),
781 );
782 }
783 };
784 let m_toGeneratorState = match m_toGeneratorState {
785 _serde::__private::Some(__field) => __field,
786 _serde::__private::None => {
787 return _serde::__private::Err(
788 <__A::Error as _serde::de::Error>::missing_field(
789 "toGeneratorState",
790 ),
791 );
792 }
793 };
794 let m_echoTransitionGenerator = match m_echoTransitionGenerator {
795 _serde::__private::Some(__field) => __field,
796 _serde::__private::None => {
797 return _serde::__private::Err(
798 <__A::Error as _serde::de::Error>::missing_field(
799 "echoTransitionGenerator",
800 ),
801 );
802 }
803 };
804 let m_echoToGenerator = match m_echoToGenerator {
805 _serde::__private::Some(__field) => __field,
806 _serde::__private::None => {
807 return _serde::__private::Err(
808 <__A::Error as _serde::de::Error>::missing_field(
809 "echoToGenerator",
810 ),
811 );
812 }
813 };
814 let m_justActivated = match m_justActivated {
815 _serde::__private::Some(__field) => __field,
816 _serde::__private::None => {
817 return _serde::__private::Err(
818 <__A::Error as _serde::de::Error>::missing_field(
819 "justActivated",
820 ),
821 );
822 }
823 };
824 let m_updateActiveNodes = match m_updateActiveNodes {
825 _serde::__private::Some(__field) => __field,
826 _serde::__private::None => {
827 return _serde::__private::Err(
828 <__A::Error as _serde::de::Error>::missing_field(
829 "updateActiveNodes",
830 ),
831 );
832 }
833 };
834 let m_stage = match m_stage {
835 _serde::__private::Some(__field) => __field,
836 _serde::__private::None => {
837 return _serde::__private::Err(
838 <__A::Error as _serde::de::Error>::missing_field("stage"),
839 );
840 }
841 };
842 _serde::__private::Ok(hkbGeneratorTransitionEffect {
843 __ptr,
844 parent,
845 m_transitionGenerator,
846 m_blendInDuration,
847 m_blendOutDuration,
848 m_syncToGeneratorStartTime,
849 m_fromGenerator,
850 m_toGenerator,
851 m_timeInTransition,
852 m_duration,
853 m_effectiveBlendInDuration,
854 m_effectiveBlendOutDuration,
855 m_toGeneratorState,
856 m_echoTransitionGenerator,
857 m_echoToGenerator,
858 m_justActivated,
859 m_updateActiveNodes,
860 m_stage,
861 })
862 }
863 #[allow(clippy::manual_unwrap_or_default)]
864 fn visit_struct<__A>(
865 self,
866 mut __map: __A,
867 ) -> _serde::__private::Result<Self::Value, __A::Error>
868 where
869 __A: _serde::de::MapAccess<'de>,
870 {
871 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
872 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
873 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
874 let mut m_selfTransitionMode: _serde::__private::Option<
875 SelfTransitionMode,
876 > = _serde::__private::None;
877 let mut m_eventMode: _serde::__private::Option<EventMode> = _serde::__private::None;
878 let mut m_transitionGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
879 let mut m_blendInDuration: _serde::__private::Option<f32> = _serde::__private::None;
880 let mut m_blendOutDuration: _serde::__private::Option<f32> = _serde::__private::None;
881 let mut m_syncToGeneratorStartTime: _serde::__private::Option<
882 bool,
883 > = _serde::__private::None;
884 while let _serde::__private::Some(__key) = {
885 __A::next_key::<__Field>(&mut __map)?
886 } {
887 match __key {
888 __Field::m_variableBindingSet => {
889 #[cfg(
890 any(feature = "strict", feature = "ignore_duplicates")
891 )]
892 if _serde::__private::Option::is_some(
893 &m_variableBindingSet,
894 ) {
895 #[cfg(feature = "ignore_duplicates")]
896 {
897 __A::skip_value(&mut __map)?;
898 continue;
899 }
900 #[cfg(feature = "strict")]
901 return _serde::__private::Err(
902 <__A::Error as _serde::de::Error>::duplicate_field(
903 "variableBindingSet",
904 ),
905 );
906 }
907 m_variableBindingSet = _serde::__private::Some(
908 match __A::next_value::<Pointer>(&mut __map) {
909 _serde::__private::Ok(__val) => __val,
910 _serde::__private::Err(__err) => {
911 return _serde::__private::Err(__err);
912 }
913 },
914 );
915 }
916 __Field::m_userData => {
917 #[cfg(
918 any(feature = "strict", feature = "ignore_duplicates")
919 )]
920 if _serde::__private::Option::is_some(&m_userData) {
921 #[cfg(feature = "ignore_duplicates")]
922 {
923 __A::skip_value(&mut __map)?;
924 continue;
925 }
926 #[cfg(feature = "strict")]
927 return _serde::__private::Err(
928 <__A::Error as _serde::de::Error>::duplicate_field(
929 "userData",
930 ),
931 );
932 }
933 m_userData = _serde::__private::Some(
934 match __A::next_value::<Ulong>(&mut __map) {
935 _serde::__private::Ok(__val) => __val,
936 _serde::__private::Err(__err) => {
937 return _serde::__private::Err(__err);
938 }
939 },
940 );
941 }
942 __Field::m_name => {
943 #[cfg(
944 any(feature = "strict", feature = "ignore_duplicates")
945 )]
946 if _serde::__private::Option::is_some(&m_name) {
947 #[cfg(feature = "ignore_duplicates")]
948 {
949 __A::skip_value(&mut __map)?;
950 continue;
951 }
952 #[cfg(feature = "strict")]
953 return _serde::__private::Err(
954 <__A::Error as _serde::de::Error>::duplicate_field("name"),
955 );
956 }
957 m_name = _serde::__private::Some(
958 match __A::next_value::<StringPtr<'de>>(&mut __map) {
959 _serde::__private::Ok(__val) => __val,
960 _serde::__private::Err(__err) => {
961 return _serde::__private::Err(__err);
962 }
963 },
964 );
965 }
966 __Field::m_selfTransitionMode => {
967 #[cfg(
968 any(feature = "strict", feature = "ignore_duplicates")
969 )]
970 if _serde::__private::Option::is_some(
971 &m_selfTransitionMode,
972 ) {
973 #[cfg(feature = "ignore_duplicates")]
974 {
975 __A::skip_value(&mut __map)?;
976 continue;
977 }
978 #[cfg(feature = "strict")]
979 return _serde::__private::Err(
980 <__A::Error as _serde::de::Error>::duplicate_field(
981 "selfTransitionMode",
982 ),
983 );
984 }
985 m_selfTransitionMode = _serde::__private::Some(
986 match __A::next_value::<SelfTransitionMode>(&mut __map) {
987 _serde::__private::Ok(__val) => __val,
988 _serde::__private::Err(__err) => {
989 return _serde::__private::Err(__err);
990 }
991 },
992 );
993 }
994 __Field::m_eventMode => {
995 #[cfg(
996 any(feature = "strict", feature = "ignore_duplicates")
997 )]
998 if _serde::__private::Option::is_some(&m_eventMode) {
999 #[cfg(feature = "ignore_duplicates")]
1000 {
1001 __A::skip_value(&mut __map)?;
1002 continue;
1003 }
1004 #[cfg(feature = "strict")]
1005 return _serde::__private::Err(
1006 <__A::Error as _serde::de::Error>::duplicate_field(
1007 "eventMode",
1008 ),
1009 );
1010 }
1011 m_eventMode = _serde::__private::Some(
1012 match __A::next_value::<EventMode>(&mut __map) {
1013 _serde::__private::Ok(__val) => __val,
1014 _serde::__private::Err(__err) => {
1015 return _serde::__private::Err(__err);
1016 }
1017 },
1018 );
1019 }
1020 __Field::m_transitionGenerator => {
1021 #[cfg(
1022 any(feature = "strict", feature = "ignore_duplicates")
1023 )]
1024 if _serde::__private::Option::is_some(
1025 &m_transitionGenerator,
1026 ) {
1027 #[cfg(feature = "ignore_duplicates")]
1028 {
1029 __A::skip_value(&mut __map)?;
1030 continue;
1031 }
1032 #[cfg(feature = "strict")]
1033 return _serde::__private::Err(
1034 <__A::Error as _serde::de::Error>::duplicate_field(
1035 "transitionGenerator",
1036 ),
1037 );
1038 }
1039 m_transitionGenerator = _serde::__private::Some(
1040 match __A::next_value::<Pointer>(&mut __map) {
1041 _serde::__private::Ok(__val) => __val,
1042 _serde::__private::Err(__err) => {
1043 return _serde::__private::Err(__err);
1044 }
1045 },
1046 );
1047 }
1048 __Field::m_blendInDuration => {
1049 #[cfg(
1050 any(feature = "strict", feature = "ignore_duplicates")
1051 )]
1052 if _serde::__private::Option::is_some(&m_blendInDuration) {
1053 #[cfg(feature = "ignore_duplicates")]
1054 {
1055 __A::skip_value(&mut __map)?;
1056 continue;
1057 }
1058 #[cfg(feature = "strict")]
1059 return _serde::__private::Err(
1060 <__A::Error as _serde::de::Error>::duplicate_field(
1061 "blendInDuration",
1062 ),
1063 );
1064 }
1065 m_blendInDuration = _serde::__private::Some(
1066 match __A::next_value::<f32>(&mut __map) {
1067 _serde::__private::Ok(__val) => __val,
1068 _serde::__private::Err(__err) => {
1069 return _serde::__private::Err(__err);
1070 }
1071 },
1072 );
1073 }
1074 __Field::m_blendOutDuration => {
1075 #[cfg(
1076 any(feature = "strict", feature = "ignore_duplicates")
1077 )]
1078 if _serde::__private::Option::is_some(&m_blendOutDuration) {
1079 #[cfg(feature = "ignore_duplicates")]
1080 {
1081 __A::skip_value(&mut __map)?;
1082 continue;
1083 }
1084 #[cfg(feature = "strict")]
1085 return _serde::__private::Err(
1086 <__A::Error as _serde::de::Error>::duplicate_field(
1087 "blendOutDuration",
1088 ),
1089 );
1090 }
1091 m_blendOutDuration = _serde::__private::Some(
1092 match __A::next_value::<f32>(&mut __map) {
1093 _serde::__private::Ok(__val) => __val,
1094 _serde::__private::Err(__err) => {
1095 return _serde::__private::Err(__err);
1096 }
1097 },
1098 );
1099 }
1100 __Field::m_syncToGeneratorStartTime => {
1101 #[cfg(
1102 any(feature = "strict", feature = "ignore_duplicates")
1103 )]
1104 if _serde::__private::Option::is_some(
1105 &m_syncToGeneratorStartTime,
1106 ) {
1107 #[cfg(feature = "ignore_duplicates")]
1108 {
1109 __A::skip_value(&mut __map)?;
1110 continue;
1111 }
1112 #[cfg(feature = "strict")]
1113 return _serde::__private::Err(
1114 <__A::Error as _serde::de::Error>::duplicate_field(
1115 "syncToGeneratorStartTime",
1116 ),
1117 );
1118 }
1119 m_syncToGeneratorStartTime = _serde::__private::Some(
1120 match __A::next_value::<bool>(&mut __map) {
1121 _serde::__private::Ok(__val) => __val,
1122 _serde::__private::Err(__err) => {
1123 return _serde::__private::Err(__err);
1124 }
1125 },
1126 );
1127 }
1128 _ => __A::skip_value(&mut __map)?,
1129 }
1130 }
1131 let m_variableBindingSet = match m_variableBindingSet {
1132 _serde::__private::Some(__field) => __field,
1133 _serde::__private::None => {
1134 #[cfg(feature = "strict")]
1135 return _serde::__private::Err(
1136 <__A::Error as _serde::de::Error>::missing_field(
1137 "variableBindingSet",
1138 ),
1139 );
1140 #[cfg(not(feature = "strict"))] Default::default()
1141 }
1142 };
1143 let m_userData = match m_userData {
1144 _serde::__private::Some(__field) => __field,
1145 _serde::__private::None => {
1146 #[cfg(feature = "strict")]
1147 return _serde::__private::Err(
1148 <__A::Error as _serde::de::Error>::missing_field("userData"),
1149 );
1150 #[cfg(not(feature = "strict"))] Default::default()
1151 }
1152 };
1153 let m_name = match m_name {
1154 _serde::__private::Some(__field) => __field,
1155 _serde::__private::None => {
1156 #[cfg(feature = "strict")]
1157 return _serde::__private::Err(
1158 <__A::Error as _serde::de::Error>::missing_field("name"),
1159 );
1160 #[cfg(not(feature = "strict"))] Default::default()
1161 }
1162 };
1163 let m_selfTransitionMode = match m_selfTransitionMode {
1164 _serde::__private::Some(__field) => __field,
1165 _serde::__private::None => {
1166 #[cfg(feature = "strict")]
1167 return _serde::__private::Err(
1168 <__A::Error as _serde::de::Error>::missing_field(
1169 "selfTransitionMode",
1170 ),
1171 );
1172 #[cfg(not(feature = "strict"))] Default::default()
1173 }
1174 };
1175 let m_eventMode = match m_eventMode {
1176 _serde::__private::Some(__field) => __field,
1177 _serde::__private::None => {
1178 #[cfg(feature = "strict")]
1179 return _serde::__private::Err(
1180 <__A::Error as _serde::de::Error>::missing_field(
1181 "eventMode",
1182 ),
1183 );
1184 #[cfg(not(feature = "strict"))] Default::default()
1185 }
1186 };
1187 let m_transitionGenerator = match m_transitionGenerator {
1188 _serde::__private::Some(__field) => __field,
1189 _serde::__private::None => {
1190 #[cfg(feature = "strict")]
1191 return _serde::__private::Err(
1192 <__A::Error as _serde::de::Error>::missing_field(
1193 "transitionGenerator",
1194 ),
1195 );
1196 #[cfg(not(feature = "strict"))] Default::default()
1197 }
1198 };
1199 let m_blendInDuration = match m_blendInDuration {
1200 _serde::__private::Some(__field) => __field,
1201 _serde::__private::None => {
1202 #[cfg(feature = "strict")]
1203 return _serde::__private::Err(
1204 <__A::Error as _serde::de::Error>::missing_field(
1205 "blendInDuration",
1206 ),
1207 );
1208 #[cfg(not(feature = "strict"))] Default::default()
1209 }
1210 };
1211 let m_blendOutDuration = match m_blendOutDuration {
1212 _serde::__private::Some(__field) => __field,
1213 _serde::__private::None => {
1214 #[cfg(feature = "strict")]
1215 return _serde::__private::Err(
1216 <__A::Error as _serde::de::Error>::missing_field(
1217 "blendOutDuration",
1218 ),
1219 );
1220 #[cfg(not(feature = "strict"))] Default::default()
1221 }
1222 };
1223 let m_syncToGeneratorStartTime = match m_syncToGeneratorStartTime {
1224 _serde::__private::Some(__field) => __field,
1225 _serde::__private::None => {
1226 #[cfg(feature = "strict")]
1227 return _serde::__private::Err(
1228 <__A::Error as _serde::de::Error>::missing_field(
1229 "syncToGeneratorStartTime",
1230 ),
1231 );
1232 #[cfg(not(feature = "strict"))] Default::default()
1233 }
1234 };
1235 let __ptr = None;
1236 let parent = hkBaseObject { __ptr };
1237 let parent = hkReferencedObject {
1238 __ptr,
1239 parent,
1240 ..Default::default()
1241 };
1242 let parent = hkbBindable {
1243 __ptr,
1244 parent,
1245 m_variableBindingSet,
1246 ..Default::default()
1247 };
1248 let parent = hkbNode {
1249 __ptr,
1250 parent,
1251 m_userData,
1252 m_name,
1253 ..Default::default()
1254 };
1255 let parent = hkbGenerator { __ptr, parent };
1256 let parent = hkbTransitionEffect {
1257 __ptr,
1258 parent,
1259 m_selfTransitionMode,
1260 m_eventMode,
1261 ..Default::default()
1262 };
1263 let __ptr = __A::class_ptr(&mut __map);
1264 _serde::__private::Ok(hkbGeneratorTransitionEffect {
1265 __ptr,
1266 parent,
1267 m_transitionGenerator,
1268 m_blendInDuration,
1269 m_blendOutDuration,
1270 m_syncToGeneratorStartTime,
1271 ..Default::default()
1272 })
1273 }
1274 }
1275 const FIELDS: &[&str] = &[
1276 "transitionGenerator",
1277 "blendInDuration",
1278 "blendOutDuration",
1279 "syncToGeneratorStartTime",
1280 "fromGenerator",
1281 "toGenerator",
1282 "timeInTransition",
1283 "duration",
1284 "effectiveBlendInDuration",
1285 "effectiveBlendOutDuration",
1286 "toGeneratorState",
1287 "echoTransitionGenerator",
1288 "echoToGenerator",
1289 "justActivated",
1290 "updateActiveNodes",
1291 "stage",
1292 ];
1293 _serde::Deserializer::deserialize_struct(
1294 deserializer,
1295 "hkbGeneratorTransitionEffect",
1296 FIELDS,
1297 __hkbGeneratorTransitionEffectVisitor {
1298 marker: _serde::__private::PhantomData::<
1299 hkbGeneratorTransitionEffect,
1300 >,
1301 lifetime: _serde::__private::PhantomData,
1302 },
1303 )
1304 }
1305 }
1306};
1307#[allow(non_upper_case_globals, non_snake_case)]
1310#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1311#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1312#[derive(
1313 Debug,
1314 Clone,
1315 Default,
1316 PartialEq,
1317 Eq,
1318 PartialOrd,
1319 Ord,
1320 num_derive::ToPrimitive,
1321 num_derive::FromPrimitive,
1322)]
1323pub enum ToGeneratorState {
1324 #[default]
1325 STATE_INACTIVE = 0isize,
1326 STATE_READY_FOR_SET_LOCAL_TIME = 1isize,
1327 STATE_READY_FOR_APPLY_SELF_TRANSITION_MODE = 2isize,
1328 STATE_ACTIVE = 3isize,
1329}
1330#[allow(non_upper_case_globals, non_snake_case)]
1333#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1334#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1335#[derive(
1336 Debug,
1337 Clone,
1338 Default,
1339 PartialEq,
1340 Eq,
1341 PartialOrd,
1342 Ord,
1343 num_derive::ToPrimitive,
1344 num_derive::FromPrimitive,
1345)]
1346pub enum Stage {
1347 #[default]
1348 STAGE_BLENDING_IN = 0isize,
1349 STAGE_PLAYING_TRANSITION_GENERATOR = 1isize,
1350 STAGE_BLENDING_OUT = 2isize,
1351}
1352const _: () = {
1353 use havok_serde as __serde;
1354 impl __serde::Serialize for ToGeneratorState {
1355 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1356 where
1357 S: __serde::ser::Serializer,
1358 {
1359 let mut __serializer = __serializer.serialize_enum_flags()?;
1360 match self {
1361 Self::STATE_INACTIVE => {
1362 __serializer.serialize_field("STATE_INACTIVE", &0u64)
1363 }
1364 Self::STATE_READY_FOR_SET_LOCAL_TIME => {
1365 __serializer.serialize_field("STATE_READY_FOR_SET_LOCAL_TIME", &1u64)
1366 }
1367 Self::STATE_READY_FOR_APPLY_SELF_TRANSITION_MODE => {
1368 __serializer
1369 .serialize_field(
1370 "STATE_READY_FOR_APPLY_SELF_TRANSITION_MODE",
1371 &2u64,
1372 )
1373 }
1374 Self::STATE_ACTIVE => __serializer.serialize_field("STATE_ACTIVE", &3u64),
1375 }?;
1376 use num_traits::ToPrimitive as _;
1377 let num = self
1378 .to_i8()
1379 .ok_or(S::Error::custom("Failed enum ToGeneratorState to_i8"))?;
1380 __serializer.serialize_bits(&num)?;
1381 __serializer.end()
1382 }
1383 }
1384};
1385const _: () = {
1386 use havok_serde as __serde;
1387 impl __serde::Serialize for Stage {
1388 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1389 where
1390 S: __serde::ser::Serializer,
1391 {
1392 let mut __serializer = __serializer.serialize_enum_flags()?;
1393 match self {
1394 Self::STAGE_BLENDING_IN => {
1395 __serializer.serialize_field("STAGE_BLENDING_IN", &0u64)
1396 }
1397 Self::STAGE_PLAYING_TRANSITION_GENERATOR => {
1398 __serializer
1399 .serialize_field("STAGE_PLAYING_TRANSITION_GENERATOR", &1u64)
1400 }
1401 Self::STAGE_BLENDING_OUT => {
1402 __serializer.serialize_field("STAGE_BLENDING_OUT", &2u64)
1403 }
1404 }?;
1405 use num_traits::ToPrimitive as _;
1406 let num = self.to_i8().ok_or(S::Error::custom("Failed enum Stage to_i8"))?;
1407 __serializer.serialize_bits(&num)?;
1408 __serializer.end()
1409 }
1410 }
1411};
1412#[doc(hidden)]
1413#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1414const _: () = {
1415 #[allow(unused_extern_crates, clippy::useless_attribute)]
1416 extern crate havok_serde as _serde;
1417 #[automatically_derived]
1418 impl<'de> _serde::Deserialize<'de> for ToGeneratorState {
1419 fn deserialize<__D>(
1420 __deserializer: __D,
1421 ) -> _serde::__private::Result<Self, __D::Error>
1422 where
1423 __D: _serde::Deserializer<'de>,
1424 {
1425 #[allow(non_camel_case_types)]
1426 #[doc(hidden)]
1427 enum __Field {
1428 __field0,
1429 __field1,
1430 __field2,
1431 __field3,
1432 }
1433 #[doc(hidden)]
1434 struct __FieldVisitor;
1435 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1436 type Value = __Field;
1437 fn expecting(
1438 &self,
1439 __formatter: &mut _serde::__private::Formatter,
1440 ) -> _serde::__private::fmt::Result {
1441 _serde::__private::Formatter::write_str(
1442 __formatter,
1443 "variant identifier",
1444 )
1445 }
1446 fn visit_int8<__E>(
1447 self,
1448 __value: i8,
1449 ) -> _serde::__private::Result<Self::Value, __E>
1450 where
1451 __E: _serde::de::Error,
1452 {
1453 match __value {
1454 0i8 => _serde::__private::Ok(__Field::__field0),
1455 1i8 => _serde::__private::Ok(__Field::__field1),
1456 2i8 => _serde::__private::Ok(__Field::__field2),
1457 3i8 => _serde::__private::Ok(__Field::__field3),
1458 _ => {
1459 _serde::__private::Err(
1460 _serde::de::Error::invalid_value(
1461 _serde::de::Unexpected::Int8(__value),
1462 &"value(i8) of variant is one of 0, 1, 2, 3",
1463 ),
1464 )
1465 }
1466 }
1467 }
1468 fn visit_stringptr<__E>(
1469 self,
1470 __value: StringPtr<'de>,
1471 ) -> _serde::__private::Result<Self::Value, __E>
1472 where
1473 __E: _serde::de::Error,
1474 {
1475 if let Some(__value) = __value.into_inner() {
1476 match __value.as_ref() {
1477 v if v == "0" || v.eq_ignore_ascii_case("STATE_INACTIVE") => {
1478 _serde::__private::Ok(__Field::__field0)
1479 }
1480 v if v == "1"
1481 || v
1482 .eq_ignore_ascii_case("STATE_READY_FOR_SET_LOCAL_TIME") => {
1483 _serde::__private::Ok(__Field::__field1)
1484 }
1485 v if v == "2"
1486 || v
1487 .eq_ignore_ascii_case(
1488 "STATE_READY_FOR_APPLY_SELF_TRANSITION_MODE",
1489 ) => _serde::__private::Ok(__Field::__field2),
1490 v if v == "3" || v.eq_ignore_ascii_case("STATE_ACTIVE") => {
1491 _serde::__private::Ok(__Field::__field3)
1492 }
1493 _ => {
1494 _serde::__private::Err(
1495 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1496 )
1497 }
1498 }
1499 } else {
1500 _serde::__private::Err(
1501 _serde::de::Error::unknown_variant("None", VARIANTS),
1502 )
1503 }
1504 }
1505 }
1506 impl<'de> _serde::Deserialize<'de> for __Field {
1507 #[inline]
1508 fn deserialize<__D>(
1509 __deserializer: __D,
1510 ) -> _serde::__private::Result<Self, __D::Error>
1511 where
1512 __D: _serde::Deserializer<'de>,
1513 {
1514 _serde::Deserializer::deserialize_identifier(
1515 __deserializer,
1516 _serde::de::ReadEnumSize::Int8,
1517 __FieldVisitor,
1518 )
1519 }
1520 }
1521 #[doc(hidden)]
1522 struct __Visitor<'de> {
1523 marker: _serde::__private::PhantomData<ToGeneratorState>,
1524 lifetime: _serde::__private::PhantomData<&'de ()>,
1525 }
1526 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1527 type Value = ToGeneratorState;
1528 fn expecting(
1529 &self,
1530 __formatter: &mut _serde::__private::Formatter,
1531 ) -> _serde::__private::fmt::Result {
1532 _serde::__private::Formatter::write_str(
1533 __formatter,
1534 "enum ToGeneratorState",
1535 )
1536 }
1537 fn visit_enum<__A>(
1538 self,
1539 __data: __A,
1540 ) -> _serde::__private::Result<Self::Value, __A::Error>
1541 where
1542 __A: _serde::de::EnumAccess<'de>,
1543 {
1544 match _serde::de::EnumAccess::variant(__data)? {
1545 (__Field::__field0, __variant) => {
1546 _serde::de::VariantAccess::unit_variant(__variant)?;
1547 _serde::__private::Ok(ToGeneratorState::STATE_INACTIVE)
1548 }
1549 (__Field::__field1, __variant) => {
1550 _serde::de::VariantAccess::unit_variant(__variant)?;
1551 _serde::__private::Ok(
1552 ToGeneratorState::STATE_READY_FOR_SET_LOCAL_TIME,
1553 )
1554 }
1555 (__Field::__field2, __variant) => {
1556 _serde::de::VariantAccess::unit_variant(__variant)?;
1557 _serde::__private::Ok(
1558 ToGeneratorState::STATE_READY_FOR_APPLY_SELF_TRANSITION_MODE,
1559 )
1560 }
1561 (__Field::__field3, __variant) => {
1562 _serde::de::VariantAccess::unit_variant(__variant)?;
1563 _serde::__private::Ok(ToGeneratorState::STATE_ACTIVE)
1564 }
1565 }
1566 }
1567 }
1568 #[doc(hidden)]
1569 const VARIANTS: &'static [&'static str] = &[
1570 "STATE_INACTIVE",
1571 "STATE_READY_FOR_SET_LOCAL_TIME",
1572 "STATE_READY_FOR_APPLY_SELF_TRANSITION_MODE",
1573 "STATE_ACTIVE",
1574 ];
1575 _serde::Deserializer::deserialize_enum(
1576 __deserializer,
1577 "ToGeneratorState",
1578 VARIANTS,
1579 __Visitor {
1580 marker: _serde::__private::PhantomData::<ToGeneratorState>,
1581 lifetime: _serde::__private::PhantomData,
1582 },
1583 )
1584 }
1585 }
1586};
1587#[doc(hidden)]
1588#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1589const _: () = {
1590 #[allow(unused_extern_crates, clippy::useless_attribute)]
1591 extern crate havok_serde as _serde;
1592 #[automatically_derived]
1593 impl<'de> _serde::Deserialize<'de> for Stage {
1594 fn deserialize<__D>(
1595 __deserializer: __D,
1596 ) -> _serde::__private::Result<Self, __D::Error>
1597 where
1598 __D: _serde::Deserializer<'de>,
1599 {
1600 #[allow(non_camel_case_types)]
1601 #[doc(hidden)]
1602 enum __Field {
1603 __field0,
1604 __field1,
1605 __field2,
1606 }
1607 #[doc(hidden)]
1608 struct __FieldVisitor;
1609 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1610 type Value = __Field;
1611 fn expecting(
1612 &self,
1613 __formatter: &mut _serde::__private::Formatter,
1614 ) -> _serde::__private::fmt::Result {
1615 _serde::__private::Formatter::write_str(
1616 __formatter,
1617 "variant identifier",
1618 )
1619 }
1620 fn visit_int8<__E>(
1621 self,
1622 __value: i8,
1623 ) -> _serde::__private::Result<Self::Value, __E>
1624 where
1625 __E: _serde::de::Error,
1626 {
1627 match __value {
1628 0i8 => _serde::__private::Ok(__Field::__field0),
1629 1i8 => _serde::__private::Ok(__Field::__field1),
1630 2i8 => _serde::__private::Ok(__Field::__field2),
1631 _ => {
1632 _serde::__private::Err(
1633 _serde::de::Error::invalid_value(
1634 _serde::de::Unexpected::Int8(__value),
1635 &"value(i8) of variant is one of 0, 1, 2",
1636 ),
1637 )
1638 }
1639 }
1640 }
1641 fn visit_stringptr<__E>(
1642 self,
1643 __value: StringPtr<'de>,
1644 ) -> _serde::__private::Result<Self::Value, __E>
1645 where
1646 __E: _serde::de::Error,
1647 {
1648 if let Some(__value) = __value.into_inner() {
1649 match __value.as_ref() {
1650 v if v == "0"
1651 || v.eq_ignore_ascii_case("STAGE_BLENDING_IN") => {
1652 _serde::__private::Ok(__Field::__field0)
1653 }
1654 v if v == "1"
1655 || v
1656 .eq_ignore_ascii_case(
1657 "STAGE_PLAYING_TRANSITION_GENERATOR",
1658 ) => _serde::__private::Ok(__Field::__field1),
1659 v if v == "2"
1660 || v.eq_ignore_ascii_case("STAGE_BLENDING_OUT") => {
1661 _serde::__private::Ok(__Field::__field2)
1662 }
1663 _ => {
1664 _serde::__private::Err(
1665 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1666 )
1667 }
1668 }
1669 } else {
1670 _serde::__private::Err(
1671 _serde::de::Error::unknown_variant("None", VARIANTS),
1672 )
1673 }
1674 }
1675 }
1676 impl<'de> _serde::Deserialize<'de> for __Field {
1677 #[inline]
1678 fn deserialize<__D>(
1679 __deserializer: __D,
1680 ) -> _serde::__private::Result<Self, __D::Error>
1681 where
1682 __D: _serde::Deserializer<'de>,
1683 {
1684 _serde::Deserializer::deserialize_identifier(
1685 __deserializer,
1686 _serde::de::ReadEnumSize::Int8,
1687 __FieldVisitor,
1688 )
1689 }
1690 }
1691 #[doc(hidden)]
1692 struct __Visitor<'de> {
1693 marker: _serde::__private::PhantomData<Stage>,
1694 lifetime: _serde::__private::PhantomData<&'de ()>,
1695 }
1696 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1697 type Value = Stage;
1698 fn expecting(
1699 &self,
1700 __formatter: &mut _serde::__private::Formatter,
1701 ) -> _serde::__private::fmt::Result {
1702 _serde::__private::Formatter::write_str(__formatter, "enum Stage")
1703 }
1704 fn visit_enum<__A>(
1705 self,
1706 __data: __A,
1707 ) -> _serde::__private::Result<Self::Value, __A::Error>
1708 where
1709 __A: _serde::de::EnumAccess<'de>,
1710 {
1711 match _serde::de::EnumAccess::variant(__data)? {
1712 (__Field::__field0, __variant) => {
1713 _serde::de::VariantAccess::unit_variant(__variant)?;
1714 _serde::__private::Ok(Stage::STAGE_BLENDING_IN)
1715 }
1716 (__Field::__field1, __variant) => {
1717 _serde::de::VariantAccess::unit_variant(__variant)?;
1718 _serde::__private::Ok(
1719 Stage::STAGE_PLAYING_TRANSITION_GENERATOR,
1720 )
1721 }
1722 (__Field::__field2, __variant) => {
1723 _serde::de::VariantAccess::unit_variant(__variant)?;
1724 _serde::__private::Ok(Stage::STAGE_BLENDING_OUT)
1725 }
1726 }
1727 }
1728 }
1729 #[doc(hidden)]
1730 const VARIANTS: &'static [&'static str] = &[
1731 "STAGE_BLENDING_IN",
1732 "STAGE_PLAYING_TRANSITION_GENERATOR",
1733 "STAGE_BLENDING_OUT",
1734 ];
1735 _serde::Deserializer::deserialize_enum(
1736 __deserializer,
1737 "Stage",
1738 VARIANTS,
1739 __Visitor {
1740 marker: _serde::__private::PhantomData::<Stage>,
1741 lifetime: _serde::__private::PhantomData,
1742 },
1743 )
1744 }
1745 }
1746};