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