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 hkbStateMachineDelayedTransitionInfo {
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 = "delayedTransition"))]
31 #[cfg_attr(feature = "serde", serde(rename = "delayedTransition"))]
32 pub m_delayedTransition: hkbStateMachineProspectiveTransitionInfo,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "timeDelayed"))]
38 #[cfg_attr(feature = "serde", serde(rename = "timeDelayed"))]
39 pub m_timeDelayed: f32,
40 #[cfg_attr(
45 feature = "json_schema",
46 schemars(rename = "isDelayedTransitionReturnToPreviousState")
47 )]
48 #[cfg_attr(
49 feature = "serde",
50 serde(rename = "isDelayedTransitionReturnToPreviousState")
51 )]
52 pub m_isDelayedTransitionReturnToPreviousState: bool,
53 #[cfg_attr(feature = "json_schema", schemars(rename = "wasInAbutRangeLastFrame"))]
58 #[cfg_attr(feature = "serde", serde(rename = "wasInAbutRangeLastFrame"))]
59 pub m_wasInAbutRangeLastFrame: bool,
60}
61const _: () = {
62 use havok_serde as _serde;
63 impl _serde::HavokClass for hkbStateMachineDelayedTransitionInfo {
64 #[inline]
65 fn name(&self) -> &'static str {
66 "hkbStateMachineDelayedTransitionInfo"
67 }
68 #[inline]
69 fn signature(&self) -> _serde::__private::Signature {
70 _serde::__private::Signature::new(0x26d5499)
71 }
72 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
73 fn deps_indexes(&self) -> Vec<usize> {
74 let mut v = Vec::new();
75 v.extend(self.m_delayedTransition.deps_indexes());
76 v
77 }
78 }
79 impl _serde::Serialize for hkbStateMachineDelayedTransitionInfo {
80 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
81 where
82 S: _serde::ser::Serializer,
83 {
84 let class_meta = self
85 .__ptr
86 .map(|name| (name, _serde::__private::Signature::new(0x26d5499)));
87 let mut serializer = __serializer
88 .serialize_struct(
89 "hkbStateMachineDelayedTransitionInfo",
90 class_meta,
91 (24u64, 24u64),
92 )?;
93 serializer.serialize_field("delayedTransition", &self.m_delayedTransition)?;
94 serializer.serialize_field("timeDelayed", &self.m_timeDelayed)?;
95 serializer
96 .serialize_field(
97 "isDelayedTransitionReturnToPreviousState",
98 &self.m_isDelayedTransitionReturnToPreviousState,
99 )?;
100 serializer
101 .serialize_field(
102 "wasInAbutRangeLastFrame",
103 &self.m_wasInAbutRangeLastFrame,
104 )?;
105 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
106 serializer.end()
107 }
108 }
109};
110#[doc(hidden)]
111#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
112const _: () = {
113 use havok_serde as _serde;
114 #[automatically_derived]
115 impl<'de> _serde::Deserialize<'de> for hkbStateMachineDelayedTransitionInfo {
116 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
117 where
118 __D: _serde::Deserializer<'de>,
119 {
120 #[allow(non_camel_case_types)]
121 enum __Field {
122 m_delayedTransition,
123 m_timeDelayed,
124 m_isDelayedTransitionReturnToPreviousState,
125 m_wasInAbutRangeLastFrame,
126 __ignore,
127 }
128 struct __FieldVisitor;
129 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
130 type Value = __Field;
131 fn expecting(
132 &self,
133 __formatter: &mut core::fmt::Formatter,
134 ) -> core::fmt::Result {
135 core::fmt::Formatter::write_str(__formatter, "field identifier")
136 }
137 #[allow(clippy::match_single_binding)]
139 #[allow(clippy::reversed_empty_ranges)]
140 #[allow(clippy::single_match)]
141 fn visit_key<__E>(
142 self,
143 __value: &str,
144 ) -> core::result::Result<Self::Value, __E>
145 where
146 __E: _serde::de::Error,
147 {
148 match __value {
149 "delayedTransition" => Ok(__Field::m_delayedTransition),
150 "timeDelayed" => Ok(__Field::m_timeDelayed),
151 "isDelayedTransitionReturnToPreviousState" => {
152 Ok(__Field::m_isDelayedTransitionReturnToPreviousState)
153 }
154 "wasInAbutRangeLastFrame" => {
155 Ok(__Field::m_wasInAbutRangeLastFrame)
156 }
157 _ => Ok(__Field::__ignore),
158 }
159 }
160 }
161 impl<'de> _serde::Deserialize<'de> for __Field {
162 #[inline]
163 fn deserialize<__D>(
164 __deserializer: __D,
165 ) -> core::result::Result<Self, __D::Error>
166 where
167 __D: _serde::Deserializer<'de>,
168 {
169 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
170 }
171 }
172 struct __hkbStateMachineDelayedTransitionInfoVisitor<'de> {
173 marker: _serde::__private::PhantomData<
174 hkbStateMachineDelayedTransitionInfo,
175 >,
176 lifetime: _serde::__private::PhantomData<&'de ()>,
177 }
178 #[allow(clippy::match_single_binding)]
179 #[allow(clippy::reversed_empty_ranges)]
180 #[allow(clippy::single_match)]
181 impl<'de> _serde::de::Visitor<'de>
182 for __hkbStateMachineDelayedTransitionInfoVisitor<'de> {
183 type Value = hkbStateMachineDelayedTransitionInfo;
184 fn expecting(
185 &self,
186 __formatter: &mut core::fmt::Formatter,
187 ) -> core::fmt::Result {
188 core::fmt::Formatter::write_str(
189 __formatter,
190 "struct hkbStateMachineDelayedTransitionInfo",
191 )
192 }
193 fn visit_struct_for_bytes<__A>(
194 self,
195 mut __map: __A,
196 ) -> _serde::__private::Result<Self::Value, __A::Error>
197 where
198 __A: _serde::de::MapAccess<'de>,
199 {
200 let __ptr = __A::class_ptr(&mut __map);
201 let mut m_delayedTransition: _serde::__private::Option<
202 hkbStateMachineProspectiveTransitionInfo,
203 > = _serde::__private::None;
204 let mut m_timeDelayed: _serde::__private::Option<f32> = _serde::__private::None;
205 let mut m_isDelayedTransitionReturnToPreviousState: _serde::__private::Option<
206 bool,
207 > = _serde::__private::None;
208 let mut m_wasInAbutRangeLastFrame: _serde::__private::Option<bool> = _serde::__private::None;
209 for i in 0..4usize {
210 match i {
211 0usize => {
212 if _serde::__private::Option::is_some(
213 &m_delayedTransition,
214 ) {
215 return _serde::__private::Err(
216 <__A::Error as _serde::de::Error>::duplicate_field(
217 "delayedTransition",
218 ),
219 );
220 }
221 m_delayedTransition = _serde::__private::Some(
222 match __A::next_value::<
223 hkbStateMachineProspectiveTransitionInfo,
224 >(&mut __map) {
225 _serde::__private::Ok(__val) => __val,
226 _serde::__private::Err(__err) => {
227 return _serde::__private::Err(__err);
228 }
229 },
230 );
231 }
232 1usize => {
233 if _serde::__private::Option::is_some(&m_timeDelayed) {
234 return _serde::__private::Err(
235 <__A::Error as _serde::de::Error>::duplicate_field(
236 "timeDelayed",
237 ),
238 );
239 }
240 m_timeDelayed = _serde::__private::Some(
241 match __A::next_value::<f32>(&mut __map) {
242 _serde::__private::Ok(__val) => __val,
243 _serde::__private::Err(__err) => {
244 return _serde::__private::Err(__err);
245 }
246 },
247 );
248 }
249 2usize => {
250 if _serde::__private::Option::is_some(
251 &m_isDelayedTransitionReturnToPreviousState,
252 ) {
253 return _serde::__private::Err(
254 <__A::Error as _serde::de::Error>::duplicate_field(
255 "isDelayedTransitionReturnToPreviousState",
256 ),
257 );
258 }
259 m_isDelayedTransitionReturnToPreviousState = _serde::__private::Some(
260 match __A::next_value::<bool>(&mut __map) {
261 _serde::__private::Ok(__val) => __val,
262 _serde::__private::Err(__err) => {
263 return _serde::__private::Err(__err);
264 }
265 },
266 );
267 }
268 3usize => {
269 if _serde::__private::Option::is_some(
270 &m_wasInAbutRangeLastFrame,
271 ) {
272 return _serde::__private::Err(
273 <__A::Error as _serde::de::Error>::duplicate_field(
274 "wasInAbutRangeLastFrame",
275 ),
276 );
277 }
278 m_wasInAbutRangeLastFrame = _serde::__private::Some(
279 match __A::next_value::<bool>(&mut __map) {
280 _serde::__private::Ok(__val) => __val,
281 _serde::__private::Err(__err) => {
282 return _serde::__private::Err(__err);
283 }
284 },
285 );
286 }
287 _ => {}
288 }
289 }
290 __A::pad(&mut __map, 2usize, 2usize)?;
291 let m_delayedTransition = match m_delayedTransition {
292 _serde::__private::Some(__field) => __field,
293 _serde::__private::None => {
294 return _serde::__private::Err(
295 <__A::Error as _serde::de::Error>::missing_field(
296 "delayedTransition",
297 ),
298 );
299 }
300 };
301 let m_timeDelayed = match m_timeDelayed {
302 _serde::__private::Some(__field) => __field,
303 _serde::__private::None => {
304 return _serde::__private::Err(
305 <__A::Error as _serde::de::Error>::missing_field(
306 "timeDelayed",
307 ),
308 );
309 }
310 };
311 let m_isDelayedTransitionReturnToPreviousState = match m_isDelayedTransitionReturnToPreviousState {
312 _serde::__private::Some(__field) => __field,
313 _serde::__private::None => {
314 return _serde::__private::Err(
315 <__A::Error as _serde::de::Error>::missing_field(
316 "isDelayedTransitionReturnToPreviousState",
317 ),
318 );
319 }
320 };
321 let m_wasInAbutRangeLastFrame = match m_wasInAbutRangeLastFrame {
322 _serde::__private::Some(__field) => __field,
323 _serde::__private::None => {
324 return _serde::__private::Err(
325 <__A::Error as _serde::de::Error>::missing_field(
326 "wasInAbutRangeLastFrame",
327 ),
328 );
329 }
330 };
331 _serde::__private::Ok(hkbStateMachineDelayedTransitionInfo {
332 __ptr,
333 m_delayedTransition,
334 m_timeDelayed,
335 m_isDelayedTransitionReturnToPreviousState,
336 m_wasInAbutRangeLastFrame,
337 })
338 }
339 #[allow(clippy::manual_unwrap_or_default)]
340 fn visit_struct<__A>(
341 self,
342 mut __map: __A,
343 ) -> _serde::__private::Result<Self::Value, __A::Error>
344 where
345 __A: _serde::de::MapAccess<'de>,
346 {
347 let mut m_delayedTransition: _serde::__private::Option<
348 hkbStateMachineProspectiveTransitionInfo,
349 > = _serde::__private::None;
350 let mut m_timeDelayed: _serde::__private::Option<f32> = _serde::__private::None;
351 let mut m_isDelayedTransitionReturnToPreviousState: _serde::__private::Option<
352 bool,
353 > = _serde::__private::None;
354 let mut m_wasInAbutRangeLastFrame: _serde::__private::Option<bool> = _serde::__private::None;
355 while let _serde::__private::Some(__key) = {
356 __A::next_key::<__Field>(&mut __map)?
357 } {
358 match __key {
359 __Field::m_delayedTransition => {
360 #[cfg(
361 any(feature = "strict", feature = "ignore_duplicates")
362 )]
363 if _serde::__private::Option::is_some(
364 &m_delayedTransition,
365 ) {
366 #[cfg(feature = "ignore_duplicates")]
367 {
368 __A::skip_value(&mut __map)?;
369 continue;
370 }
371 #[cfg(feature = "strict")]
372 return _serde::__private::Err(
373 <__A::Error as _serde::de::Error>::duplicate_field(
374 "delayedTransition",
375 ),
376 );
377 }
378 m_delayedTransition = _serde::__private::Some(
379 match __A::next_value::<
380 hkbStateMachineProspectiveTransitionInfo,
381 >(&mut __map) {
382 _serde::__private::Ok(__val) => __val,
383 _serde::__private::Err(__err) => {
384 return _serde::__private::Err(__err);
385 }
386 },
387 );
388 }
389 __Field::m_timeDelayed => {
390 #[cfg(
391 any(feature = "strict", feature = "ignore_duplicates")
392 )]
393 if _serde::__private::Option::is_some(&m_timeDelayed) {
394 #[cfg(feature = "ignore_duplicates")]
395 {
396 __A::skip_value(&mut __map)?;
397 continue;
398 }
399 #[cfg(feature = "strict")]
400 return _serde::__private::Err(
401 <__A::Error as _serde::de::Error>::duplicate_field(
402 "timeDelayed",
403 ),
404 );
405 }
406 m_timeDelayed = _serde::__private::Some(
407 match __A::next_value::<f32>(&mut __map) {
408 _serde::__private::Ok(__val) => __val,
409 _serde::__private::Err(__err) => {
410 return _serde::__private::Err(__err);
411 }
412 },
413 );
414 }
415 __Field::m_isDelayedTransitionReturnToPreviousState => {
416 #[cfg(
417 any(feature = "strict", feature = "ignore_duplicates")
418 )]
419 if _serde::__private::Option::is_some(
420 &m_isDelayedTransitionReturnToPreviousState,
421 ) {
422 #[cfg(feature = "ignore_duplicates")]
423 {
424 __A::skip_value(&mut __map)?;
425 continue;
426 }
427 #[cfg(feature = "strict")]
428 return _serde::__private::Err(
429 <__A::Error as _serde::de::Error>::duplicate_field(
430 "isDelayedTransitionReturnToPreviousState",
431 ),
432 );
433 }
434 m_isDelayedTransitionReturnToPreviousState = _serde::__private::Some(
435 match __A::next_value::<bool>(&mut __map) {
436 _serde::__private::Ok(__val) => __val,
437 _serde::__private::Err(__err) => {
438 return _serde::__private::Err(__err);
439 }
440 },
441 );
442 }
443 __Field::m_wasInAbutRangeLastFrame => {
444 #[cfg(
445 any(feature = "strict", feature = "ignore_duplicates")
446 )]
447 if _serde::__private::Option::is_some(
448 &m_wasInAbutRangeLastFrame,
449 ) {
450 #[cfg(feature = "ignore_duplicates")]
451 {
452 __A::skip_value(&mut __map)?;
453 continue;
454 }
455 #[cfg(feature = "strict")]
456 return _serde::__private::Err(
457 <__A::Error as _serde::de::Error>::duplicate_field(
458 "wasInAbutRangeLastFrame",
459 ),
460 );
461 }
462 m_wasInAbutRangeLastFrame = _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 _ => __A::skip_value(&mut __map)?,
472 }
473 }
474 let m_delayedTransition = match m_delayedTransition {
475 _serde::__private::Some(__field) => __field,
476 _serde::__private::None => {
477 #[cfg(feature = "strict")]
478 return _serde::__private::Err(
479 <__A::Error as _serde::de::Error>::missing_field(
480 "delayedTransition",
481 ),
482 );
483 #[cfg(not(feature = "strict"))] Default::default()
484 }
485 };
486 let m_timeDelayed = match m_timeDelayed {
487 _serde::__private::Some(__field) => __field,
488 _serde::__private::None => {
489 #[cfg(feature = "strict")]
490 return _serde::__private::Err(
491 <__A::Error as _serde::de::Error>::missing_field(
492 "timeDelayed",
493 ),
494 );
495 #[cfg(not(feature = "strict"))] Default::default()
496 }
497 };
498 let m_isDelayedTransitionReturnToPreviousState = match m_isDelayedTransitionReturnToPreviousState {
499 _serde::__private::Some(__field) => __field,
500 _serde::__private::None => {
501 #[cfg(feature = "strict")]
502 return _serde::__private::Err(
503 <__A::Error as _serde::de::Error>::missing_field(
504 "isDelayedTransitionReturnToPreviousState",
505 ),
506 );
507 #[cfg(not(feature = "strict"))] Default::default()
508 }
509 };
510 let m_wasInAbutRangeLastFrame = match m_wasInAbutRangeLastFrame {
511 _serde::__private::Some(__field) => __field,
512 _serde::__private::None => {
513 #[cfg(feature = "strict")]
514 return _serde::__private::Err(
515 <__A::Error as _serde::de::Error>::missing_field(
516 "wasInAbutRangeLastFrame",
517 ),
518 );
519 #[cfg(not(feature = "strict"))] Default::default()
520 }
521 };
522 let __ptr = __A::class_ptr(&mut __map);
523 _serde::__private::Ok(hkbStateMachineDelayedTransitionInfo {
524 __ptr,
525 m_delayedTransition,
526 m_timeDelayed,
527 m_isDelayedTransitionReturnToPreviousState,
528 m_wasInAbutRangeLastFrame,
529 })
530 }
531 }
532 const FIELDS: &[&str] = &[
533 "delayedTransition",
534 "timeDelayed",
535 "isDelayedTransitionReturnToPreviousState",
536 "wasInAbutRangeLastFrame",
537 ];
538 _serde::Deserializer::deserialize_struct(
539 deserializer,
540 "hkbStateMachineDelayedTransitionInfo",
541 FIELDS,
542 __hkbStateMachineDelayedTransitionInfoVisitor {
543 marker: _serde::__private::PhantomData::<
544 hkbStateMachineDelayedTransitionInfo,
545 >,
546 lifetime: _serde::__private::PhantomData,
547 },
548 )
549 }
550 }
551};