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 hkbStateMachineTransitionInfo {
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(rename = "triggerInterval"))]
31 #[cfg_attr(feature = "serde", serde(rename = "triggerInterval"))]
32 pub m_triggerInterval: hkbStateMachineTimeInterval,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "initiateInterval"))]
38 #[cfg_attr(feature = "serde", serde(rename = "initiateInterval"))]
39 pub m_initiateInterval: hkbStateMachineTimeInterval,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "transition"))]
45 #[cfg_attr(feature = "serde", serde(rename = "transition"))]
46 pub m_transition: Pointer,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "condition"))]
52 #[cfg_attr(feature = "serde", serde(rename = "condition"))]
53 pub m_condition: Pointer,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "eventId"))]
59 #[cfg_attr(feature = "serde", serde(rename = "eventId"))]
60 pub m_eventId: i32,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "toStateId"))]
66 #[cfg_attr(feature = "serde", serde(rename = "toStateId"))]
67 pub m_toStateId: i32,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "fromNestedStateId"))]
73 #[cfg_attr(feature = "serde", serde(rename = "fromNestedStateId"))]
74 pub m_fromNestedStateId: i32,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "toNestedStateId"))]
80 #[cfg_attr(feature = "serde", serde(rename = "toNestedStateId"))]
81 pub m_toNestedStateId: i32,
82 #[cfg_attr(feature = "json_schema", schemars(rename = "priority"))]
87 #[cfg_attr(feature = "serde", serde(rename = "priority"))]
88 pub m_priority: i16,
89 #[cfg_attr(feature = "json_schema", schemars(rename = "flags"))]
94 #[cfg_attr(feature = "serde", serde(rename = "flags"))]
95 pub m_flags: TransitionFlags,
96}
97const _: () = {
98 use havok_serde as _serde;
99 impl _serde::HavokClass for hkbStateMachineTransitionInfo {
100 #[inline]
101 fn name(&self) -> &'static str {
102 "hkbStateMachineTransitionInfo"
103 }
104 #[inline]
105 fn signature(&self) -> _serde::__private::Signature {
106 _serde::__private::Signature::new(0xcdec8025)
107 }
108 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
109 fn deps_indexes(&self) -> Vec<usize> {
110 let mut v = Vec::new();
111 v.extend(self.m_triggerInterval.deps_indexes());
112 v.extend(self.m_initiateInterval.deps_indexes());
113 v.push(self.m_transition.get());
114 v.push(self.m_condition.get());
115 v
116 }
117 }
118 impl _serde::Serialize for hkbStateMachineTransitionInfo {
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(0xcdec8025)));
126 let mut serializer = __serializer
127 .serialize_struct(
128 "hkbStateMachineTransitionInfo",
129 class_meta,
130 (60u64, 72u64),
131 )?;
132 serializer.serialize_field("triggerInterval", &self.m_triggerInterval)?;
133 serializer.serialize_field("initiateInterval", &self.m_initiateInterval)?;
134 serializer.serialize_field("transition", &self.m_transition)?;
135 serializer.serialize_field("condition", &self.m_condition)?;
136 serializer.serialize_field("eventId", &self.m_eventId)?;
137 serializer.serialize_field("toStateId", &self.m_toStateId)?;
138 serializer.serialize_field("fromNestedStateId", &self.m_fromNestedStateId)?;
139 serializer.serialize_field("toNestedStateId", &self.m_toNestedStateId)?;
140 serializer.serialize_field("priority", &self.m_priority)?;
141 serializer.serialize_field("flags", &self.m_flags)?;
142 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
143 serializer.end()
144 }
145 }
146};
147#[doc(hidden)]
148#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
149const _: () = {
150 use havok_serde as _serde;
151 #[automatically_derived]
152 impl<'de> _serde::Deserialize<'de> for hkbStateMachineTransitionInfo {
153 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
154 where
155 __D: _serde::Deserializer<'de>,
156 {
157 #[allow(non_camel_case_types)]
158 enum __Field {
159 m_triggerInterval,
160 m_initiateInterval,
161 m_transition,
162 m_condition,
163 m_eventId,
164 m_toStateId,
165 m_fromNestedStateId,
166 m_toNestedStateId,
167 m_priority,
168 m_flags,
169 __ignore,
170 }
171 struct __FieldVisitor;
172 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
173 type Value = __Field;
174 fn expecting(
175 &self,
176 __formatter: &mut core::fmt::Formatter,
177 ) -> core::fmt::Result {
178 core::fmt::Formatter::write_str(__formatter, "field identifier")
179 }
180 #[allow(clippy::match_single_binding)]
182 #[allow(clippy::reversed_empty_ranges)]
183 #[allow(clippy::single_match)]
184 fn visit_key<__E>(
185 self,
186 __value: &str,
187 ) -> core::result::Result<Self::Value, __E>
188 where
189 __E: _serde::de::Error,
190 {
191 match __value {
192 "triggerInterval" => Ok(__Field::m_triggerInterval),
193 "initiateInterval" => Ok(__Field::m_initiateInterval),
194 "transition" => Ok(__Field::m_transition),
195 "condition" => Ok(__Field::m_condition),
196 "eventId" => Ok(__Field::m_eventId),
197 "toStateId" => Ok(__Field::m_toStateId),
198 "fromNestedStateId" => Ok(__Field::m_fromNestedStateId),
199 "toNestedStateId" => Ok(__Field::m_toNestedStateId),
200 "priority" => Ok(__Field::m_priority),
201 "flags" => Ok(__Field::m_flags),
202 _ => Ok(__Field::__ignore),
203 }
204 }
205 }
206 impl<'de> _serde::Deserialize<'de> for __Field {
207 #[inline]
208 fn deserialize<__D>(
209 __deserializer: __D,
210 ) -> core::result::Result<Self, __D::Error>
211 where
212 __D: _serde::Deserializer<'de>,
213 {
214 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
215 }
216 }
217 struct __hkbStateMachineTransitionInfoVisitor<'de> {
218 marker: _serde::__private::PhantomData<hkbStateMachineTransitionInfo>,
219 lifetime: _serde::__private::PhantomData<&'de ()>,
220 }
221 #[allow(clippy::match_single_binding)]
222 #[allow(clippy::reversed_empty_ranges)]
223 #[allow(clippy::single_match)]
224 impl<'de> _serde::de::Visitor<'de>
225 for __hkbStateMachineTransitionInfoVisitor<'de> {
226 type Value = hkbStateMachineTransitionInfo;
227 fn expecting(
228 &self,
229 __formatter: &mut core::fmt::Formatter,
230 ) -> core::fmt::Result {
231 core::fmt::Formatter::write_str(
232 __formatter,
233 "struct hkbStateMachineTransitionInfo",
234 )
235 }
236 fn visit_struct_for_bytes<__A>(
237 self,
238 mut __map: __A,
239 ) -> _serde::__private::Result<Self::Value, __A::Error>
240 where
241 __A: _serde::de::MapAccess<'de>,
242 {
243 let __ptr = __A::class_ptr(&mut __map);
244 let mut m_triggerInterval: _serde::__private::Option<
245 hkbStateMachineTimeInterval,
246 > = _serde::__private::None;
247 let mut m_initiateInterval: _serde::__private::Option<
248 hkbStateMachineTimeInterval,
249 > = _serde::__private::None;
250 let mut m_transition: _serde::__private::Option<Pointer> = _serde::__private::None;
251 let mut m_condition: _serde::__private::Option<Pointer> = _serde::__private::None;
252 let mut m_eventId: _serde::__private::Option<i32> = _serde::__private::None;
253 let mut m_toStateId: _serde::__private::Option<i32> = _serde::__private::None;
254 let mut m_fromNestedStateId: _serde::__private::Option<i32> = _serde::__private::None;
255 let mut m_toNestedStateId: _serde::__private::Option<i32> = _serde::__private::None;
256 let mut m_priority: _serde::__private::Option<i16> = _serde::__private::None;
257 let mut m_flags: _serde::__private::Option<TransitionFlags> = _serde::__private::None;
258 for i in 0..10usize {
259 match i {
260 0usize => {
261 if _serde::__private::Option::is_some(&m_triggerInterval) {
262 return _serde::__private::Err(
263 <__A::Error as _serde::de::Error>::duplicate_field(
264 "triggerInterval",
265 ),
266 );
267 }
268 m_triggerInterval = _serde::__private::Some(
269 match __A::next_value::<
270 hkbStateMachineTimeInterval,
271 >(&mut __map) {
272 _serde::__private::Ok(__val) => __val,
273 _serde::__private::Err(__err) => {
274 return _serde::__private::Err(__err);
275 }
276 },
277 );
278 }
279 1usize => {
280 if _serde::__private::Option::is_some(&m_initiateInterval) {
281 return _serde::__private::Err(
282 <__A::Error as _serde::de::Error>::duplicate_field(
283 "initiateInterval",
284 ),
285 );
286 }
287 m_initiateInterval = _serde::__private::Some(
288 match __A::next_value::<
289 hkbStateMachineTimeInterval,
290 >(&mut __map) {
291 _serde::__private::Ok(__val) => __val,
292 _serde::__private::Err(__err) => {
293 return _serde::__private::Err(__err);
294 }
295 },
296 );
297 }
298 2usize => {
299 if _serde::__private::Option::is_some(&m_transition) {
300 return _serde::__private::Err(
301 <__A::Error as _serde::de::Error>::duplicate_field(
302 "transition",
303 ),
304 );
305 }
306 m_transition = _serde::__private::Some(
307 match __A::next_value::<Pointer>(&mut __map) {
308 _serde::__private::Ok(__val) => __val,
309 _serde::__private::Err(__err) => {
310 return _serde::__private::Err(__err);
311 }
312 },
313 );
314 }
315 3usize => {
316 if _serde::__private::Option::is_some(&m_condition) {
317 return _serde::__private::Err(
318 <__A::Error as _serde::de::Error>::duplicate_field(
319 "condition",
320 ),
321 );
322 }
323 m_condition = _serde::__private::Some(
324 match __A::next_value::<Pointer>(&mut __map) {
325 _serde::__private::Ok(__val) => __val,
326 _serde::__private::Err(__err) => {
327 return _serde::__private::Err(__err);
328 }
329 },
330 );
331 }
332 4usize => {
333 if _serde::__private::Option::is_some(&m_eventId) {
334 return _serde::__private::Err(
335 <__A::Error as _serde::de::Error>::duplicate_field(
336 "eventId",
337 ),
338 );
339 }
340 m_eventId = _serde::__private::Some(
341 match __A::next_value::<i32>(&mut __map) {
342 _serde::__private::Ok(__val) => __val,
343 _serde::__private::Err(__err) => {
344 return _serde::__private::Err(__err);
345 }
346 },
347 );
348 }
349 5usize => {
350 if _serde::__private::Option::is_some(&m_toStateId) {
351 return _serde::__private::Err(
352 <__A::Error as _serde::de::Error>::duplicate_field(
353 "toStateId",
354 ),
355 );
356 }
357 m_toStateId = _serde::__private::Some(
358 match __A::next_value::<i32>(&mut __map) {
359 _serde::__private::Ok(__val) => __val,
360 _serde::__private::Err(__err) => {
361 return _serde::__private::Err(__err);
362 }
363 },
364 );
365 }
366 6usize => {
367 if _serde::__private::Option::is_some(
368 &m_fromNestedStateId,
369 ) {
370 return _serde::__private::Err(
371 <__A::Error as _serde::de::Error>::duplicate_field(
372 "fromNestedStateId",
373 ),
374 );
375 }
376 m_fromNestedStateId = _serde::__private::Some(
377 match __A::next_value::<i32>(&mut __map) {
378 _serde::__private::Ok(__val) => __val,
379 _serde::__private::Err(__err) => {
380 return _serde::__private::Err(__err);
381 }
382 },
383 );
384 }
385 7usize => {
386 if _serde::__private::Option::is_some(&m_toNestedStateId) {
387 return _serde::__private::Err(
388 <__A::Error as _serde::de::Error>::duplicate_field(
389 "toNestedStateId",
390 ),
391 );
392 }
393 m_toNestedStateId = _serde::__private::Some(
394 match __A::next_value::<i32>(&mut __map) {
395 _serde::__private::Ok(__val) => __val,
396 _serde::__private::Err(__err) => {
397 return _serde::__private::Err(__err);
398 }
399 },
400 );
401 }
402 8usize => {
403 if _serde::__private::Option::is_some(&m_priority) {
404 return _serde::__private::Err(
405 <__A::Error as _serde::de::Error>::duplicate_field(
406 "priority",
407 ),
408 );
409 }
410 m_priority = _serde::__private::Some(
411 match __A::next_value::<i16>(&mut __map) {
412 _serde::__private::Ok(__val) => __val,
413 _serde::__private::Err(__err) => {
414 return _serde::__private::Err(__err);
415 }
416 },
417 );
418 }
419 9usize => {
420 if _serde::__private::Option::is_some(&m_flags) {
421 return _serde::__private::Err(
422 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
423 );
424 }
425 m_flags = _serde::__private::Some(
426 match __A::next_value::<TransitionFlags>(&mut __map) {
427 _serde::__private::Ok(__val) => __val,
428 _serde::__private::Err(__err) => {
429 return _serde::__private::Err(__err);
430 }
431 },
432 );
433 }
434 _ => {}
435 }
436 }
437 __A::pad(&mut __map, 0usize, 4usize)?;
438 let m_triggerInterval = match m_triggerInterval {
439 _serde::__private::Some(__field) => __field,
440 _serde::__private::None => {
441 return _serde::__private::Err(
442 <__A::Error as _serde::de::Error>::missing_field(
443 "triggerInterval",
444 ),
445 );
446 }
447 };
448 let m_initiateInterval = match m_initiateInterval {
449 _serde::__private::Some(__field) => __field,
450 _serde::__private::None => {
451 return _serde::__private::Err(
452 <__A::Error as _serde::de::Error>::missing_field(
453 "initiateInterval",
454 ),
455 );
456 }
457 };
458 let m_transition = match m_transition {
459 _serde::__private::Some(__field) => __field,
460 _serde::__private::None => {
461 return _serde::__private::Err(
462 <__A::Error as _serde::de::Error>::missing_field(
463 "transition",
464 ),
465 );
466 }
467 };
468 let m_condition = match m_condition {
469 _serde::__private::Some(__field) => __field,
470 _serde::__private::None => {
471 return _serde::__private::Err(
472 <__A::Error as _serde::de::Error>::missing_field(
473 "condition",
474 ),
475 );
476 }
477 };
478 let m_eventId = match m_eventId {
479 _serde::__private::Some(__field) => __field,
480 _serde::__private::None => {
481 return _serde::__private::Err(
482 <__A::Error as _serde::de::Error>::missing_field("eventId"),
483 );
484 }
485 };
486 let m_toStateId = match m_toStateId {
487 _serde::__private::Some(__field) => __field,
488 _serde::__private::None => {
489 return _serde::__private::Err(
490 <__A::Error as _serde::de::Error>::missing_field(
491 "toStateId",
492 ),
493 );
494 }
495 };
496 let m_fromNestedStateId = match m_fromNestedStateId {
497 _serde::__private::Some(__field) => __field,
498 _serde::__private::None => {
499 return _serde::__private::Err(
500 <__A::Error as _serde::de::Error>::missing_field(
501 "fromNestedStateId",
502 ),
503 );
504 }
505 };
506 let m_toNestedStateId = match m_toNestedStateId {
507 _serde::__private::Some(__field) => __field,
508 _serde::__private::None => {
509 return _serde::__private::Err(
510 <__A::Error as _serde::de::Error>::missing_field(
511 "toNestedStateId",
512 ),
513 );
514 }
515 };
516 let m_priority = match m_priority {
517 _serde::__private::Some(__field) => __field,
518 _serde::__private::None => {
519 return _serde::__private::Err(
520 <__A::Error as _serde::de::Error>::missing_field("priority"),
521 );
522 }
523 };
524 let m_flags = match m_flags {
525 _serde::__private::Some(__field) => __field,
526 _serde::__private::None => {
527 return _serde::__private::Err(
528 <__A::Error as _serde::de::Error>::missing_field("flags"),
529 );
530 }
531 };
532 _serde::__private::Ok(hkbStateMachineTransitionInfo {
533 __ptr,
534 m_triggerInterval,
535 m_initiateInterval,
536 m_transition,
537 m_condition,
538 m_eventId,
539 m_toStateId,
540 m_fromNestedStateId,
541 m_toNestedStateId,
542 m_priority,
543 m_flags,
544 })
545 }
546 #[allow(clippy::manual_unwrap_or_default)]
547 fn visit_struct<__A>(
548 self,
549 mut __map: __A,
550 ) -> _serde::__private::Result<Self::Value, __A::Error>
551 where
552 __A: _serde::de::MapAccess<'de>,
553 {
554 let mut m_triggerInterval: _serde::__private::Option<
555 hkbStateMachineTimeInterval,
556 > = _serde::__private::None;
557 let mut m_initiateInterval: _serde::__private::Option<
558 hkbStateMachineTimeInterval,
559 > = _serde::__private::None;
560 let mut m_transition: _serde::__private::Option<Pointer> = _serde::__private::None;
561 let mut m_condition: _serde::__private::Option<Pointer> = _serde::__private::None;
562 let mut m_eventId: _serde::__private::Option<i32> = _serde::__private::None;
563 let mut m_toStateId: _serde::__private::Option<i32> = _serde::__private::None;
564 let mut m_fromNestedStateId: _serde::__private::Option<i32> = _serde::__private::None;
565 let mut m_toNestedStateId: _serde::__private::Option<i32> = _serde::__private::None;
566 let mut m_priority: _serde::__private::Option<i16> = _serde::__private::None;
567 let mut m_flags: _serde::__private::Option<TransitionFlags> = _serde::__private::None;
568 while let _serde::__private::Some(__key) = {
569 __A::next_key::<__Field>(&mut __map)?
570 } {
571 match __key {
572 __Field::m_triggerInterval => {
573 #[cfg(
574 any(feature = "strict", feature = "ignore_duplicates")
575 )]
576 if _serde::__private::Option::is_some(&m_triggerInterval) {
577 #[cfg(feature = "ignore_duplicates")]
578 {
579 __A::skip_value(&mut __map)?;
580 continue;
581 }
582 #[cfg(feature = "strict")]
583 return _serde::__private::Err(
584 <__A::Error as _serde::de::Error>::duplicate_field(
585 "triggerInterval",
586 ),
587 );
588 }
589 m_triggerInterval = _serde::__private::Some(
590 match __A::next_value::<
591 hkbStateMachineTimeInterval,
592 >(&mut __map) {
593 _serde::__private::Ok(__val) => __val,
594 _serde::__private::Err(__err) => {
595 return _serde::__private::Err(__err);
596 }
597 },
598 );
599 }
600 __Field::m_initiateInterval => {
601 #[cfg(
602 any(feature = "strict", feature = "ignore_duplicates")
603 )]
604 if _serde::__private::Option::is_some(&m_initiateInterval) {
605 #[cfg(feature = "ignore_duplicates")]
606 {
607 __A::skip_value(&mut __map)?;
608 continue;
609 }
610 #[cfg(feature = "strict")]
611 return _serde::__private::Err(
612 <__A::Error as _serde::de::Error>::duplicate_field(
613 "initiateInterval",
614 ),
615 );
616 }
617 m_initiateInterval = _serde::__private::Some(
618 match __A::next_value::<
619 hkbStateMachineTimeInterval,
620 >(&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_transition => {
629 #[cfg(
630 any(feature = "strict", feature = "ignore_duplicates")
631 )]
632 if _serde::__private::Option::is_some(&m_transition) {
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 "transition",
642 ),
643 );
644 }
645 m_transition = _serde::__private::Some(
646 match __A::next_value::<Pointer>(&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_condition => {
655 #[cfg(
656 any(feature = "strict", feature = "ignore_duplicates")
657 )]
658 if _serde::__private::Option::is_some(&m_condition) {
659 #[cfg(feature = "ignore_duplicates")]
660 {
661 __A::skip_value(&mut __map)?;
662 continue;
663 }
664 #[cfg(feature = "strict")]
665 return _serde::__private::Err(
666 <__A::Error as _serde::de::Error>::duplicate_field(
667 "condition",
668 ),
669 );
670 }
671 m_condition = _serde::__private::Some(
672 match __A::next_value::<Pointer>(&mut __map) {
673 _serde::__private::Ok(__val) => __val,
674 _serde::__private::Err(__err) => {
675 return _serde::__private::Err(__err);
676 }
677 },
678 );
679 }
680 __Field::m_eventId => {
681 #[cfg(
682 any(feature = "strict", feature = "ignore_duplicates")
683 )]
684 if _serde::__private::Option::is_some(&m_eventId) {
685 #[cfg(feature = "ignore_duplicates")]
686 {
687 __A::skip_value(&mut __map)?;
688 continue;
689 }
690 #[cfg(feature = "strict")]
691 return _serde::__private::Err(
692 <__A::Error as _serde::de::Error>::duplicate_field(
693 "eventId",
694 ),
695 );
696 }
697 m_eventId = _serde::__private::Some(
698 match __A::next_value::<i32>(&mut __map) {
699 _serde::__private::Ok(__val) => __val,
700 _serde::__private::Err(__err) => {
701 return _serde::__private::Err(__err);
702 }
703 },
704 );
705 }
706 __Field::m_toStateId => {
707 #[cfg(
708 any(feature = "strict", feature = "ignore_duplicates")
709 )]
710 if _serde::__private::Option::is_some(&m_toStateId) {
711 #[cfg(feature = "ignore_duplicates")]
712 {
713 __A::skip_value(&mut __map)?;
714 continue;
715 }
716 #[cfg(feature = "strict")]
717 return _serde::__private::Err(
718 <__A::Error as _serde::de::Error>::duplicate_field(
719 "toStateId",
720 ),
721 );
722 }
723 m_toStateId = _serde::__private::Some(
724 match __A::next_value::<i32>(&mut __map) {
725 _serde::__private::Ok(__val) => __val,
726 _serde::__private::Err(__err) => {
727 return _serde::__private::Err(__err);
728 }
729 },
730 );
731 }
732 __Field::m_fromNestedStateId => {
733 #[cfg(
734 any(feature = "strict", feature = "ignore_duplicates")
735 )]
736 if _serde::__private::Option::is_some(
737 &m_fromNestedStateId,
738 ) {
739 #[cfg(feature = "ignore_duplicates")]
740 {
741 __A::skip_value(&mut __map)?;
742 continue;
743 }
744 #[cfg(feature = "strict")]
745 return _serde::__private::Err(
746 <__A::Error as _serde::de::Error>::duplicate_field(
747 "fromNestedStateId",
748 ),
749 );
750 }
751 m_fromNestedStateId = _serde::__private::Some(
752 match __A::next_value::<i32>(&mut __map) {
753 _serde::__private::Ok(__val) => __val,
754 _serde::__private::Err(__err) => {
755 return _serde::__private::Err(__err);
756 }
757 },
758 );
759 }
760 __Field::m_toNestedStateId => {
761 #[cfg(
762 any(feature = "strict", feature = "ignore_duplicates")
763 )]
764 if _serde::__private::Option::is_some(&m_toNestedStateId) {
765 #[cfg(feature = "ignore_duplicates")]
766 {
767 __A::skip_value(&mut __map)?;
768 continue;
769 }
770 #[cfg(feature = "strict")]
771 return _serde::__private::Err(
772 <__A::Error as _serde::de::Error>::duplicate_field(
773 "toNestedStateId",
774 ),
775 );
776 }
777 m_toNestedStateId = _serde::__private::Some(
778 match __A::next_value::<i32>(&mut __map) {
779 _serde::__private::Ok(__val) => __val,
780 _serde::__private::Err(__err) => {
781 return _serde::__private::Err(__err);
782 }
783 },
784 );
785 }
786 __Field::m_priority => {
787 #[cfg(
788 any(feature = "strict", feature = "ignore_duplicates")
789 )]
790 if _serde::__private::Option::is_some(&m_priority) {
791 #[cfg(feature = "ignore_duplicates")]
792 {
793 __A::skip_value(&mut __map)?;
794 continue;
795 }
796 #[cfg(feature = "strict")]
797 return _serde::__private::Err(
798 <__A::Error as _serde::de::Error>::duplicate_field(
799 "priority",
800 ),
801 );
802 }
803 m_priority = _serde::__private::Some(
804 match __A::next_value::<i16>(&mut __map) {
805 _serde::__private::Ok(__val) => __val,
806 _serde::__private::Err(__err) => {
807 return _serde::__private::Err(__err);
808 }
809 },
810 );
811 }
812 __Field::m_flags => {
813 #[cfg(
814 any(feature = "strict", feature = "ignore_duplicates")
815 )]
816 if _serde::__private::Option::is_some(&m_flags) {
817 #[cfg(feature = "ignore_duplicates")]
818 {
819 __A::skip_value(&mut __map)?;
820 continue;
821 }
822 #[cfg(feature = "strict")]
823 return _serde::__private::Err(
824 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
825 );
826 }
827 m_flags = _serde::__private::Some(
828 match __A::next_value::<TransitionFlags>(&mut __map) {
829 _serde::__private::Ok(__val) => __val,
830 _serde::__private::Err(__err) => {
831 return _serde::__private::Err(__err);
832 }
833 },
834 );
835 }
836 _ => __A::skip_value(&mut __map)?,
837 }
838 }
839 let m_triggerInterval = match m_triggerInterval {
840 _serde::__private::Some(__field) => __field,
841 _serde::__private::None => {
842 #[cfg(feature = "strict")]
843 return _serde::__private::Err(
844 <__A::Error as _serde::de::Error>::missing_field(
845 "triggerInterval",
846 ),
847 );
848 #[cfg(not(feature = "strict"))] Default::default()
849 }
850 };
851 let m_initiateInterval = match m_initiateInterval {
852 _serde::__private::Some(__field) => __field,
853 _serde::__private::None => {
854 #[cfg(feature = "strict")]
855 return _serde::__private::Err(
856 <__A::Error as _serde::de::Error>::missing_field(
857 "initiateInterval",
858 ),
859 );
860 #[cfg(not(feature = "strict"))] Default::default()
861 }
862 };
863 let m_transition = match m_transition {
864 _serde::__private::Some(__field) => __field,
865 _serde::__private::None => {
866 #[cfg(feature = "strict")]
867 return _serde::__private::Err(
868 <__A::Error as _serde::de::Error>::missing_field(
869 "transition",
870 ),
871 );
872 #[cfg(not(feature = "strict"))] Default::default()
873 }
874 };
875 let m_condition = match m_condition {
876 _serde::__private::Some(__field) => __field,
877 _serde::__private::None => {
878 #[cfg(feature = "strict")]
879 return _serde::__private::Err(
880 <__A::Error as _serde::de::Error>::missing_field(
881 "condition",
882 ),
883 );
884 #[cfg(not(feature = "strict"))] Default::default()
885 }
886 };
887 let m_eventId = match m_eventId {
888 _serde::__private::Some(__field) => __field,
889 _serde::__private::None => {
890 #[cfg(feature = "strict")]
891 return _serde::__private::Err(
892 <__A::Error as _serde::de::Error>::missing_field("eventId"),
893 );
894 #[cfg(not(feature = "strict"))] Default::default()
895 }
896 };
897 let m_toStateId = match m_toStateId {
898 _serde::__private::Some(__field) => __field,
899 _serde::__private::None => {
900 #[cfg(feature = "strict")]
901 return _serde::__private::Err(
902 <__A::Error as _serde::de::Error>::missing_field(
903 "toStateId",
904 ),
905 );
906 #[cfg(not(feature = "strict"))] Default::default()
907 }
908 };
909 let m_fromNestedStateId = match m_fromNestedStateId {
910 _serde::__private::Some(__field) => __field,
911 _serde::__private::None => {
912 #[cfg(feature = "strict")]
913 return _serde::__private::Err(
914 <__A::Error as _serde::de::Error>::missing_field(
915 "fromNestedStateId",
916 ),
917 );
918 #[cfg(not(feature = "strict"))] Default::default()
919 }
920 };
921 let m_toNestedStateId = match m_toNestedStateId {
922 _serde::__private::Some(__field) => __field,
923 _serde::__private::None => {
924 #[cfg(feature = "strict")]
925 return _serde::__private::Err(
926 <__A::Error as _serde::de::Error>::missing_field(
927 "toNestedStateId",
928 ),
929 );
930 #[cfg(not(feature = "strict"))] Default::default()
931 }
932 };
933 let m_priority = match m_priority {
934 _serde::__private::Some(__field) => __field,
935 _serde::__private::None => {
936 #[cfg(feature = "strict")]
937 return _serde::__private::Err(
938 <__A::Error as _serde::de::Error>::missing_field("priority"),
939 );
940 #[cfg(not(feature = "strict"))] Default::default()
941 }
942 };
943 let m_flags = match m_flags {
944 _serde::__private::Some(__field) => __field,
945 _serde::__private::None => {
946 #[cfg(feature = "strict")]
947 return _serde::__private::Err(
948 <__A::Error as _serde::de::Error>::missing_field("flags"),
949 );
950 #[cfg(not(feature = "strict"))] Default::default()
951 }
952 };
953 let __ptr = __A::class_ptr(&mut __map);
954 _serde::__private::Ok(hkbStateMachineTransitionInfo {
955 __ptr,
956 m_triggerInterval,
957 m_initiateInterval,
958 m_transition,
959 m_condition,
960 m_eventId,
961 m_toStateId,
962 m_fromNestedStateId,
963 m_toNestedStateId,
964 m_priority,
965 m_flags,
966 })
967 }
968 }
969 const FIELDS: &[&str] = &[
970 "triggerInterval",
971 "initiateInterval",
972 "transition",
973 "condition",
974 "eventId",
975 "toStateId",
976 "fromNestedStateId",
977 "toNestedStateId",
978 "priority",
979 "flags",
980 ];
981 _serde::Deserializer::deserialize_struct(
982 deserializer,
983 "hkbStateMachineTransitionInfo",
984 FIELDS,
985 __hkbStateMachineTransitionInfoVisitor {
986 marker: _serde::__private::PhantomData::<
987 hkbStateMachineTransitionInfo,
988 >,
989 lifetime: _serde::__private::PhantomData,
990 },
991 )
992 }
993 }
994};
995#[havok_types_derive::impl_flags_methods]
996bitflags::bitflags! {
997 #[doc = r" Bit flags"] #[doc = r""] #[doc = r" # C++ Info"] #[doc =
998 " - name: `TransitionFlags`(ctype: `hkFlags<TransitionFlags, hkInt16>`)"]
999 #[allow(non_upper_case_globals, non_snake_case)] #[cfg_attr(feature = "serde",
1000 derive(serde_with::SerializeDisplay, serde_with::DeserializeFromStr))]
1001 #[repr(transparent)] #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct
1002 TransitionFlags : i16 { #[doc = "1"] const FLAG_USE_TRIGGER_INTERVAL = 1i16; #[doc =
1003 "2"] const FLAG_USE_INITIATE_INTERVAL = 2i16; #[doc = "4"] const
1004 FLAG_UNINTERRUPTIBLE_WHILE_PLAYING = 4i16; #[doc = "8"] const
1005 FLAG_UNINTERRUPTIBLE_WHILE_DELAYED = 8i16; #[doc = "16"] const
1006 FLAG_DELAY_STATE_CHANGE = 16i16; #[doc = "32"] const FLAG_DISABLED = 32i16; #[doc =
1007 "64"] const FLAG_DISALLOW_RETURN_TO_PREVIOUS_STATE = 64i16; #[doc = "128"] const
1008 FLAG_DISALLOW_RANDOM_TRANSITION = 128i16; #[doc = "256"] const FLAG_DISABLE_CONDITION
1009 = 256i16; #[doc = "512"] const
1010 FLAG_ALLOW_SELF_TRANSITION_BY_TRANSITION_FROM_ANY_STATE = 512i16; #[doc = "1024"]
1011 const FLAG_IS_GLOBAL_WILDCARD = 1024i16; #[doc = "2048"] const FLAG_IS_LOCAL_WILDCARD
1012 = 2048i16; #[doc = "4096"] const FLAG_FROM_NESTED_STATE_ID_IS_VALID = 4096i16; #[doc
1013 = "8192"] const FLAG_TO_NESTED_STATE_ID_IS_VALID = 8192i16; #[doc = "16384"] const
1014 FLAG_ABUT_AT_END_OF_FROM_GENERATOR = 16384i16; }
1015}
1016#[cfg(feature = "json_schema")]
1017const _: () = {
1018 use schemars::{SchemaGenerator, Schema, JsonSchema, json_schema};
1019 use std::borrow::Cow;
1020 impl JsonSchema for TransitionFlags {
1021 fn schema_name() -> Cow<'static, str> {
1022 "TransitionFlags".into()
1023 }
1024 fn schema_id() -> Cow<'static, str> {
1025 concat!(module_path!(), "::", "TransitionFlags").into()
1026 }
1027 fn json_schema(_generate: &mut SchemaGenerator) -> Schema {
1028 json_schema!(
1029 { "description" :
1030 "Bitflags field. Specific flags: FLAG_USE_TRIGGER_INTERVAL: 1, FLAG_USE_INITIATE_INTERVAL: 2, FLAG_UNINTERRUPTIBLE_WHILE_PLAYING: 4, FLAG_UNINTERRUPTIBLE_WHILE_DELAYED: 8, FLAG_DELAY_STATE_CHANGE: 16, FLAG_DISABLED: 32, FLAG_DISALLOW_RETURN_TO_PREVIOUS_STATE: 64, FLAG_DISALLOW_RANDOM_TRANSITION: 128, FLAG_DISABLE_CONDITION: 256, FLAG_ALLOW_SELF_TRANSITION_BY_TRANSITION_FROM_ANY_STATE: 512, FLAG_IS_GLOBAL_WILDCARD: 1024, FLAG_IS_LOCAL_WILDCARD: 2048, FLAG_FROM_NESTED_STATE_ID_IS_VALID: 4096, FLAG_TO_NESTED_STATE_ID_IS_VALID: 8192, FLAG_ABUT_AT_END_OF_FROM_GENERATOR: 16384. Additional unspecified bits may be set.(e.g.: BIT_FLAG|BIT_FLAG2|4)",
1031 "type" : "string", }
1032 )
1033 }
1034 }
1035};
1036const _: () = {
1037 use havok_serde as __serde;
1038 impl __serde::Serialize for TransitionFlags {
1039 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1040 where
1041 S: __serde::ser::Serializer,
1042 {
1043 let mut __serializer = __serializer.serialize_enum_flags()?;
1044 if self.is_empty() {
1045 __serializer.serialize_bits(&self.bits())?;
1046 __serializer.serialize_empty_bit()?;
1047 return __serializer.end();
1048 }
1049 for flag in self.iter() {
1050 match flag {
1051 Self::FLAG_USE_TRIGGER_INTERVAL => {
1052 __serializer
1053 .serialize_field(
1054 "FLAG_USE_TRIGGER_INTERVAL",
1055 &Self::FLAG_USE_TRIGGER_INTERVAL,
1056 )
1057 }
1058 Self::FLAG_USE_INITIATE_INTERVAL => {
1059 __serializer
1060 .serialize_field(
1061 "FLAG_USE_INITIATE_INTERVAL",
1062 &Self::FLAG_USE_INITIATE_INTERVAL,
1063 )
1064 }
1065 Self::FLAG_UNINTERRUPTIBLE_WHILE_PLAYING => {
1066 __serializer
1067 .serialize_field(
1068 "FLAG_UNINTERRUPTIBLE_WHILE_PLAYING",
1069 &Self::FLAG_UNINTERRUPTIBLE_WHILE_PLAYING,
1070 )
1071 }
1072 Self::FLAG_UNINTERRUPTIBLE_WHILE_DELAYED => {
1073 __serializer
1074 .serialize_field(
1075 "FLAG_UNINTERRUPTIBLE_WHILE_DELAYED",
1076 &Self::FLAG_UNINTERRUPTIBLE_WHILE_DELAYED,
1077 )
1078 }
1079 Self::FLAG_DELAY_STATE_CHANGE => {
1080 __serializer
1081 .serialize_field(
1082 "FLAG_DELAY_STATE_CHANGE",
1083 &Self::FLAG_DELAY_STATE_CHANGE,
1084 )
1085 }
1086 Self::FLAG_DISABLED => {
1087 __serializer
1088 .serialize_field("FLAG_DISABLED", &Self::FLAG_DISABLED)
1089 }
1090 Self::FLAG_DISALLOW_RETURN_TO_PREVIOUS_STATE => {
1091 __serializer
1092 .serialize_field(
1093 "FLAG_DISALLOW_RETURN_TO_PREVIOUS_STATE",
1094 &Self::FLAG_DISALLOW_RETURN_TO_PREVIOUS_STATE,
1095 )
1096 }
1097 Self::FLAG_DISALLOW_RANDOM_TRANSITION => {
1098 __serializer
1099 .serialize_field(
1100 "FLAG_DISALLOW_RANDOM_TRANSITION",
1101 &Self::FLAG_DISALLOW_RANDOM_TRANSITION,
1102 )
1103 }
1104 Self::FLAG_DISABLE_CONDITION => {
1105 __serializer
1106 .serialize_field(
1107 "FLAG_DISABLE_CONDITION",
1108 &Self::FLAG_DISABLE_CONDITION,
1109 )
1110 }
1111 Self::FLAG_ALLOW_SELF_TRANSITION_BY_TRANSITION_FROM_ANY_STATE => {
1112 __serializer
1113 .serialize_field(
1114 "FLAG_ALLOW_SELF_TRANSITION_BY_TRANSITION_FROM_ANY_STATE",
1115 &Self::FLAG_ALLOW_SELF_TRANSITION_BY_TRANSITION_FROM_ANY_STATE,
1116 )
1117 }
1118 Self::FLAG_IS_GLOBAL_WILDCARD => {
1119 __serializer
1120 .serialize_field(
1121 "FLAG_IS_GLOBAL_WILDCARD",
1122 &Self::FLAG_IS_GLOBAL_WILDCARD,
1123 )
1124 }
1125 Self::FLAG_IS_LOCAL_WILDCARD => {
1126 __serializer
1127 .serialize_field(
1128 "FLAG_IS_LOCAL_WILDCARD",
1129 &Self::FLAG_IS_LOCAL_WILDCARD,
1130 )
1131 }
1132 Self::FLAG_FROM_NESTED_STATE_ID_IS_VALID => {
1133 __serializer
1134 .serialize_field(
1135 "FLAG_FROM_NESTED_STATE_ID_IS_VALID",
1136 &Self::FLAG_FROM_NESTED_STATE_ID_IS_VALID,
1137 )
1138 }
1139 Self::FLAG_TO_NESTED_STATE_ID_IS_VALID => {
1140 __serializer
1141 .serialize_field(
1142 "FLAG_TO_NESTED_STATE_ID_IS_VALID",
1143 &Self::FLAG_TO_NESTED_STATE_ID_IS_VALID,
1144 )
1145 }
1146 Self::FLAG_ABUT_AT_END_OF_FROM_GENERATOR => {
1147 __serializer
1148 .serialize_field(
1149 "FLAG_ABUT_AT_END_OF_FROM_GENERATOR",
1150 &Self::FLAG_ABUT_AT_END_OF_FROM_GENERATOR,
1151 )
1152 }
1153 remain => {
1154 __serializer
1155 .serialize_field(&remain.bits().to_string(), &remain.bits())
1156 }
1157 }?;
1158 }
1159 __serializer.serialize_bits(&self.bits())?;
1160 __serializer.end()
1161 }
1162 }
1163};
1164#[doc(hidden)]
1165#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1166const _: () = {
1167 #[allow(unused_extern_crates, clippy::useless_attribute)]
1168 extern crate havok_serde as _serde;
1169 #[automatically_derived]
1170 impl<'de> _serde::Deserialize<'de> for TransitionFlags {
1171 fn deserialize<__D>(
1172 __deserializer: __D,
1173 ) -> _serde::__private::Result<Self, __D::Error>
1174 where
1175 __D: _serde::Deserializer<'de>,
1176 {
1177 #[doc(hidden)]
1178 struct __Visitor<'de> {
1179 marker: _serde::__private::PhantomData<TransitionFlags>,
1180 lifetime: _serde::__private::PhantomData<&'de ()>,
1181 }
1182 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1183 type Value = TransitionFlags;
1184 fn expecting(
1185 &self,
1186 __formatter: &mut _serde::__private::Formatter,
1187 ) -> _serde::__private::fmt::Result {
1188 _serde::__private::Formatter::write_str(
1189 __formatter,
1190 "struct TransitionFlags(flags)",
1191 )
1192 }
1193 #[inline]
1194 fn visit_int16<__E>(
1195 self,
1196 __value: i16,
1197 ) -> _serde::__private::Result<Self::Value, __E>
1198 where
1199 __E: _serde::de::Error,
1200 {
1201 Ok(TransitionFlags::from_bits_retain(__value as _))
1202 }
1203 fn visit_stringptr<__E>(
1204 self,
1205 __value: StringPtr<'de>,
1206 ) -> _serde::__private::Result<Self::Value, __E>
1207 where
1208 __E: _serde::de::Error,
1209 {
1210 match <TransitionFlags as core::str::FromStr>::from_str(
1211 __value.into_inner().unwrap().as_ref(),
1212 ) {
1213 Ok(flags) => Ok(flags),
1214 Err(err) => Err(_serde::de::Error::custom(err)),
1215 }
1216 }
1217 }
1218 _serde::Deserializer::deserialize_flags(
1219 __deserializer,
1220 _serde::de::ReadEnumSize::Int16,
1221 __Visitor {
1222 marker: _serde::__private::PhantomData::<TransitionFlags>,
1223 lifetime: _serde::__private::PhantomData,
1224 },
1225 )
1226 }
1227 }
1228};