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 hkbPoseMatchingGenerator<'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: hkbBlenderGenerator<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "worldFromModelRotation"))]
36 #[cfg_attr(feature = "serde", serde(rename = "worldFromModelRotation"))]
37 pub m_worldFromModelRotation: Quaternion,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "blendSpeed"))]
43 #[cfg_attr(feature = "serde", serde(rename = "blendSpeed"))]
44 pub m_blendSpeed: f32,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "minSpeedToSwitch"))]
50 #[cfg_attr(feature = "serde", serde(rename = "minSpeedToSwitch"))]
51 pub m_minSpeedToSwitch: f32,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "minSwitchTimeNoError"))]
57 #[cfg_attr(feature = "serde", serde(rename = "minSwitchTimeNoError"))]
58 pub m_minSwitchTimeNoError: f32,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "minSwitchTimeFullError"))]
64 #[cfg_attr(feature = "serde", serde(rename = "minSwitchTimeFullError"))]
65 pub m_minSwitchTimeFullError: f32,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "startPlayingEventId"))]
71 #[cfg_attr(feature = "serde", serde(rename = "startPlayingEventId"))]
72 pub m_startPlayingEventId: i32,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "startMatchingEventId"))]
78 #[cfg_attr(feature = "serde", serde(rename = "startMatchingEventId"))]
79 pub m_startMatchingEventId: i32,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "rootBoneIndex"))]
85 #[cfg_attr(feature = "serde", serde(rename = "rootBoneIndex"))]
86 pub m_rootBoneIndex: i16,
87 #[cfg_attr(feature = "json_schema", schemars(rename = "otherBoneIndex"))]
92 #[cfg_attr(feature = "serde", serde(rename = "otherBoneIndex"))]
93 pub m_otherBoneIndex: i16,
94 #[cfg_attr(feature = "json_schema", schemars(rename = "anotherBoneIndex"))]
99 #[cfg_attr(feature = "serde", serde(rename = "anotherBoneIndex"))]
100 pub m_anotherBoneIndex: i16,
101 #[cfg_attr(feature = "json_schema", schemars(rename = "pelvisIndex"))]
106 #[cfg_attr(feature = "serde", serde(rename = "pelvisIndex"))]
107 pub m_pelvisIndex: i16,
108 #[cfg_attr(feature = "json_schema", schemars(rename = "mode"))]
113 #[cfg_attr(feature = "serde", serde(rename = "mode"))]
114 pub m_mode: Mode,
115 #[cfg_attr(feature = "json_schema", schemars(rename = "currentMatch"))]
121 #[cfg_attr(feature = "serde", serde(rename = "currentMatch"))]
122 pub m_currentMatch: i32,
123 #[cfg_attr(feature = "json_schema", schemars(rename = "bestMatch"))]
129 #[cfg_attr(feature = "serde", serde(rename = "bestMatch"))]
130 pub m_bestMatch: i32,
131 #[cfg_attr(feature = "json_schema", schemars(rename = "timeSinceBetterMatch"))]
137 #[cfg_attr(feature = "serde", serde(rename = "timeSinceBetterMatch"))]
138 pub m_timeSinceBetterMatch: f32,
139 #[cfg_attr(feature = "json_schema", schemars(rename = "error"))]
145 #[cfg_attr(feature = "serde", serde(rename = "error"))]
146 pub m_error: f32,
147 #[cfg_attr(feature = "json_schema", schemars(rename = "resetCurrentMatchLocalTime"))]
153 #[cfg_attr(feature = "serde", serde(rename = "resetCurrentMatchLocalTime"))]
154 pub m_resetCurrentMatchLocalTime: bool,
155 #[cfg_attr(feature = "json_schema", schemars(rename = "poseMatchingUtility"))]
161 #[cfg_attr(feature = "serde", serde(rename = "poseMatchingUtility"))]
162 pub m_poseMatchingUtility: Pointer,
163}
164const _: () = {
165 use havok_serde as _serde;
166 impl<'a> _serde::HavokClass for hkbPoseMatchingGenerator<'a> {
167 #[inline]
168 fn name(&self) -> &'static str {
169 "hkbPoseMatchingGenerator"
170 }
171 #[inline]
172 fn signature(&self) -> _serde::__private::Signature {
173 _serde::__private::Signature::new(0x29e271b4)
174 }
175 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
176 fn deps_indexes(&self) -> Vec<usize> {
177 let mut v = Vec::new();
178 v.push(self.parent.parent.parent.parent.m_variableBindingSet.get());
179 v.extend(self.parent.m_children.iter().map(|ptr| ptr.get()));
180 v.push(self.m_poseMatchingUtility.get());
181 v
182 }
183 }
184 impl<'a> _serde::Serialize for hkbPoseMatchingGenerator<'a> {
185 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
186 where
187 S: _serde::ser::Serializer,
188 {
189 let class_meta = self
190 .__ptr
191 .map(|name| (name, _serde::__private::Signature::new(0x29e271b4)));
192 let mut serializer = __serializer
193 .serialize_struct(
194 "hkbPoseMatchingGenerator",
195 class_meta,
196 (208u64, 240u64),
197 )?;
198 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
199 serializer
200 .skip_field(
201 "memSizeAndFlags",
202 &self.parent.parent.parent.parent.parent.m_memSizeAndFlags,
203 )?;
204 serializer
205 .skip_field(
206 "referenceCount",
207 &self.parent.parent.parent.parent.parent.m_referenceCount,
208 )?;
209 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
210 serializer
211 .serialize_field(
212 "variableBindingSet",
213 &self.parent.parent.parent.parent.m_variableBindingSet,
214 )?;
215 serializer
216 .skip_array_field(
217 "cachedBindables",
218 &self.parent.parent.parent.parent.m_cachedBindables,
219 TypeSize::NonPtr,
220 )?;
221 serializer
222 .skip_field(
223 "areBindablesCached",
224 &self.parent.parent.parent.parent.m_areBindablesCached,
225 )?;
226 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
227 serializer
228 .serialize_field("userData", &self.parent.parent.parent.m_userData)?;
229 serializer.serialize_field("name", &self.parent.parent.parent.m_name)?;
230 serializer.skip_field("id", &self.parent.parent.parent.m_id)?;
231 serializer
232 .skip_field("cloneState", &self.parent.parent.parent.m_cloneState)?;
233 serializer
234 .skip_fixed_array_field(
235 "padNode",
236 self.parent.parent.parent.m_padNode.as_slice(),
237 TypeSize::NonPtr,
238 )?;
239 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
240 serializer
241 .serialize_field(
242 "referencePoseWeightThreshold",
243 &self.parent.m_referencePoseWeightThreshold,
244 )?;
245 serializer.serialize_field("blendParameter", &self.parent.m_blendParameter)?;
246 serializer
247 .serialize_field(
248 "minCyclicBlendParameter",
249 &self.parent.m_minCyclicBlendParameter,
250 )?;
251 serializer
252 .serialize_field(
253 "maxCyclicBlendParameter",
254 &self.parent.m_maxCyclicBlendParameter,
255 )?;
256 serializer
257 .serialize_field(
258 "indexOfSyncMasterChild",
259 &self.parent.m_indexOfSyncMasterChild,
260 )?;
261 serializer.serialize_field("flags", &self.parent.m_flags)?;
262 serializer
263 .serialize_field("subtractLastChild", &self.parent.m_subtractLastChild)?;
264 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
265 serializer
266 .serialize_array_field(
267 "children",
268 &self.parent.m_children,
269 TypeSize::NonPtr,
270 )?;
271 serializer
272 .skip_array_field(
273 "childrenInternalStates",
274 &self.parent.m_childrenInternalStates,
275 TypeSize::NonPtr,
276 )?;
277 serializer
278 .skip_array_field(
279 "sortedChildren",
280 &self.parent.m_sortedChildren,
281 TypeSize::NonPtr,
282 )?;
283 serializer
284 .skip_field("endIntervalWeight", &self.parent.m_endIntervalWeight)?;
285 serializer
286 .skip_field("numActiveChildren", &self.parent.m_numActiveChildren)?;
287 serializer
288 .skip_field("beginIntervalIndex", &self.parent.m_beginIntervalIndex)?;
289 serializer.skip_field("endIntervalIndex", &self.parent.m_endIntervalIndex)?;
290 serializer.skip_field("initSync", &self.parent.m_initSync)?;
291 serializer
292 .skip_field("doSubtractiveBlend", &self.parent.m_doSubtractiveBlend)?;
293 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
294 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 0usize].as_slice())?;
295 serializer
296 .serialize_field(
297 "worldFromModelRotation",
298 &self.m_worldFromModelRotation,
299 )?;
300 serializer.serialize_field("blendSpeed", &self.m_blendSpeed)?;
301 serializer.serialize_field("minSpeedToSwitch", &self.m_minSpeedToSwitch)?;
302 serializer
303 .serialize_field("minSwitchTimeNoError", &self.m_minSwitchTimeNoError)?;
304 serializer
305 .serialize_field(
306 "minSwitchTimeFullError",
307 &self.m_minSwitchTimeFullError,
308 )?;
309 serializer
310 .serialize_field("startPlayingEventId", &self.m_startPlayingEventId)?;
311 serializer
312 .serialize_field("startMatchingEventId", &self.m_startMatchingEventId)?;
313 serializer.serialize_field("rootBoneIndex", &self.m_rootBoneIndex)?;
314 serializer.serialize_field("otherBoneIndex", &self.m_otherBoneIndex)?;
315 serializer.serialize_field("anotherBoneIndex", &self.m_anotherBoneIndex)?;
316 serializer.serialize_field("pelvisIndex", &self.m_pelvisIndex)?;
317 serializer.serialize_field("mode", &self.m_mode)?;
318 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
319 serializer.skip_field("currentMatch", &self.m_currentMatch)?;
320 serializer.skip_field("bestMatch", &self.m_bestMatch)?;
321 serializer.skip_field("timeSinceBetterMatch", &self.m_timeSinceBetterMatch)?;
322 serializer.skip_field("error", &self.m_error)?;
323 serializer
324 .skip_field(
325 "resetCurrentMatchLocalTime",
326 &self.m_resetCurrentMatchLocalTime,
327 )?;
328 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
329 serializer.skip_field("poseMatchingUtility", &self.m_poseMatchingUtility)?;
330 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
331 serializer.end()
332 }
333 }
334};
335#[doc(hidden)]
336#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
337const _: () = {
338 use havok_serde as _serde;
339 #[automatically_derived]
340 impl<'de> _serde::Deserialize<'de> for hkbPoseMatchingGenerator<'de> {
341 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
342 where
343 __D: _serde::Deserializer<'de>,
344 {
345 #[allow(non_camel_case_types)]
346 enum __Field {
347 m_variableBindingSet,
348 m_userData,
349 m_name,
350 m_referencePoseWeightThreshold,
351 m_blendParameter,
352 m_minCyclicBlendParameter,
353 m_maxCyclicBlendParameter,
354 m_indexOfSyncMasterChild,
355 m_flags,
356 m_subtractLastChild,
357 m_children,
358 m_worldFromModelRotation,
359 m_blendSpeed,
360 m_minSpeedToSwitch,
361 m_minSwitchTimeNoError,
362 m_minSwitchTimeFullError,
363 m_startPlayingEventId,
364 m_startMatchingEventId,
365 m_rootBoneIndex,
366 m_otherBoneIndex,
367 m_anotherBoneIndex,
368 m_pelvisIndex,
369 m_mode,
370 __ignore,
371 }
372 struct __FieldVisitor;
373 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
374 type Value = __Field;
375 fn expecting(
376 &self,
377 __formatter: &mut core::fmt::Formatter,
378 ) -> core::fmt::Result {
379 core::fmt::Formatter::write_str(__formatter, "field identifier")
380 }
381 #[allow(clippy::match_single_binding)]
383 #[allow(clippy::reversed_empty_ranges)]
384 #[allow(clippy::single_match)]
385 fn visit_key<__E>(
386 self,
387 __value: &str,
388 ) -> core::result::Result<Self::Value, __E>
389 where
390 __E: _serde::de::Error,
391 {
392 match __value {
393 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
394 "userData" => Ok(__Field::m_userData),
395 "name" => Ok(__Field::m_name),
396 "referencePoseWeightThreshold" => {
397 Ok(__Field::m_referencePoseWeightThreshold)
398 }
399 "blendParameter" => Ok(__Field::m_blendParameter),
400 "minCyclicBlendParameter" => {
401 Ok(__Field::m_minCyclicBlendParameter)
402 }
403 "maxCyclicBlendParameter" => {
404 Ok(__Field::m_maxCyclicBlendParameter)
405 }
406 "indexOfSyncMasterChild" => Ok(__Field::m_indexOfSyncMasterChild),
407 "flags" => Ok(__Field::m_flags),
408 "subtractLastChild" => Ok(__Field::m_subtractLastChild),
409 "children" => Ok(__Field::m_children),
410 "worldFromModelRotation" => Ok(__Field::m_worldFromModelRotation),
411 "blendSpeed" => Ok(__Field::m_blendSpeed),
412 "minSpeedToSwitch" => Ok(__Field::m_minSpeedToSwitch),
413 "minSwitchTimeNoError" => Ok(__Field::m_minSwitchTimeNoError),
414 "minSwitchTimeFullError" => Ok(__Field::m_minSwitchTimeFullError),
415 "startPlayingEventId" => Ok(__Field::m_startPlayingEventId),
416 "startMatchingEventId" => Ok(__Field::m_startMatchingEventId),
417 "rootBoneIndex" => Ok(__Field::m_rootBoneIndex),
418 "otherBoneIndex" => Ok(__Field::m_otherBoneIndex),
419 "anotherBoneIndex" => Ok(__Field::m_anotherBoneIndex),
420 "pelvisIndex" => Ok(__Field::m_pelvisIndex),
421 "mode" => Ok(__Field::m_mode),
422 _ => Ok(__Field::__ignore),
423 }
424 }
425 }
426 impl<'de> _serde::Deserialize<'de> for __Field {
427 #[inline]
428 fn deserialize<__D>(
429 __deserializer: __D,
430 ) -> core::result::Result<Self, __D::Error>
431 where
432 __D: _serde::Deserializer<'de>,
433 {
434 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
435 }
436 }
437 struct __hkbPoseMatchingGeneratorVisitor<'de> {
438 marker: _serde::__private::PhantomData<hkbPoseMatchingGenerator<'de>>,
439 lifetime: _serde::__private::PhantomData<&'de ()>,
440 }
441 #[allow(clippy::match_single_binding)]
442 #[allow(clippy::reversed_empty_ranges)]
443 #[allow(clippy::single_match)]
444 impl<'de> _serde::de::Visitor<'de>
445 for __hkbPoseMatchingGeneratorVisitor<'de> {
446 type Value = hkbPoseMatchingGenerator<'de>;
447 fn expecting(
448 &self,
449 __formatter: &mut core::fmt::Formatter,
450 ) -> core::fmt::Result {
451 core::fmt::Formatter::write_str(
452 __formatter,
453 "struct hkbPoseMatchingGenerator",
454 )
455 }
456 fn visit_struct_for_bytes<__A>(
457 self,
458 mut __map: __A,
459 ) -> _serde::__private::Result<Self::Value, __A::Error>
460 where
461 __A: _serde::de::MapAccess<'de>,
462 {
463 let __ptr = __A::class_ptr(&mut __map);
464 let parent = __A::parent_value(&mut __map)?;
465 let mut m_worldFromModelRotation: _serde::__private::Option<
466 Quaternion,
467 > = _serde::__private::None;
468 let mut m_blendSpeed: _serde::__private::Option<f32> = _serde::__private::None;
469 let mut m_minSpeedToSwitch: _serde::__private::Option<f32> = _serde::__private::None;
470 let mut m_minSwitchTimeNoError: _serde::__private::Option<f32> = _serde::__private::None;
471 let mut m_minSwitchTimeFullError: _serde::__private::Option<f32> = _serde::__private::None;
472 let mut m_startPlayingEventId: _serde::__private::Option<i32> = _serde::__private::None;
473 let mut m_startMatchingEventId: _serde::__private::Option<i32> = _serde::__private::None;
474 let mut m_rootBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
475 let mut m_otherBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
476 let mut m_anotherBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
477 let mut m_pelvisIndex: _serde::__private::Option<i16> = _serde::__private::None;
478 let mut m_mode: _serde::__private::Option<Mode> = _serde::__private::None;
479 let mut m_currentMatch: _serde::__private::Option<i32> = _serde::__private::None;
480 let mut m_bestMatch: _serde::__private::Option<i32> = _serde::__private::None;
481 let mut m_timeSinceBetterMatch: _serde::__private::Option<f32> = _serde::__private::None;
482 let mut m_error: _serde::__private::Option<f32> = _serde::__private::None;
483 let mut m_resetCurrentMatchLocalTime: _serde::__private::Option<
484 bool,
485 > = _serde::__private::None;
486 let mut m_poseMatchingUtility: _serde::__private::Option<Pointer> = _serde::__private::None;
487 for i in 0..18usize {
488 match i {
489 0usize => {
490 if _serde::__private::Option::is_some(
491 &m_worldFromModelRotation,
492 ) {
493 return _serde::__private::Err(
494 <__A::Error as _serde::de::Error>::duplicate_field(
495 "worldFromModelRotation",
496 ),
497 );
498 }
499 __A::pad(&mut __map, 12usize, 0usize)?;
500 m_worldFromModelRotation = _serde::__private::Some(
501 match __A::next_value::<Quaternion>(&mut __map) {
502 _serde::__private::Ok(__val) => __val,
503 _serde::__private::Err(__err) => {
504 return _serde::__private::Err(__err);
505 }
506 },
507 );
508 }
509 1usize => {
510 if _serde::__private::Option::is_some(&m_blendSpeed) {
511 return _serde::__private::Err(
512 <__A::Error as _serde::de::Error>::duplicate_field(
513 "blendSpeed",
514 ),
515 );
516 }
517 m_blendSpeed = _serde::__private::Some(
518 match __A::next_value::<f32>(&mut __map) {
519 _serde::__private::Ok(__val) => __val,
520 _serde::__private::Err(__err) => {
521 return _serde::__private::Err(__err);
522 }
523 },
524 );
525 }
526 2usize => {
527 if _serde::__private::Option::is_some(&m_minSpeedToSwitch) {
528 return _serde::__private::Err(
529 <__A::Error as _serde::de::Error>::duplicate_field(
530 "minSpeedToSwitch",
531 ),
532 );
533 }
534 m_minSpeedToSwitch = _serde::__private::Some(
535 match __A::next_value::<f32>(&mut __map) {
536 _serde::__private::Ok(__val) => __val,
537 _serde::__private::Err(__err) => {
538 return _serde::__private::Err(__err);
539 }
540 },
541 );
542 }
543 3usize => {
544 if _serde::__private::Option::is_some(
545 &m_minSwitchTimeNoError,
546 ) {
547 return _serde::__private::Err(
548 <__A::Error as _serde::de::Error>::duplicate_field(
549 "minSwitchTimeNoError",
550 ),
551 );
552 }
553 m_minSwitchTimeNoError = _serde::__private::Some(
554 match __A::next_value::<f32>(&mut __map) {
555 _serde::__private::Ok(__val) => __val,
556 _serde::__private::Err(__err) => {
557 return _serde::__private::Err(__err);
558 }
559 },
560 );
561 }
562 4usize => {
563 if _serde::__private::Option::is_some(
564 &m_minSwitchTimeFullError,
565 ) {
566 return _serde::__private::Err(
567 <__A::Error as _serde::de::Error>::duplicate_field(
568 "minSwitchTimeFullError",
569 ),
570 );
571 }
572 m_minSwitchTimeFullError = _serde::__private::Some(
573 match __A::next_value::<f32>(&mut __map) {
574 _serde::__private::Ok(__val) => __val,
575 _serde::__private::Err(__err) => {
576 return _serde::__private::Err(__err);
577 }
578 },
579 );
580 }
581 5usize => {
582 if _serde::__private::Option::is_some(
583 &m_startPlayingEventId,
584 ) {
585 return _serde::__private::Err(
586 <__A::Error as _serde::de::Error>::duplicate_field(
587 "startPlayingEventId",
588 ),
589 );
590 }
591 m_startPlayingEventId = _serde::__private::Some(
592 match __A::next_value::<i32>(&mut __map) {
593 _serde::__private::Ok(__val) => __val,
594 _serde::__private::Err(__err) => {
595 return _serde::__private::Err(__err);
596 }
597 },
598 );
599 }
600 6usize => {
601 if _serde::__private::Option::is_some(
602 &m_startMatchingEventId,
603 ) {
604 return _serde::__private::Err(
605 <__A::Error as _serde::de::Error>::duplicate_field(
606 "startMatchingEventId",
607 ),
608 );
609 }
610 m_startMatchingEventId = _serde::__private::Some(
611 match __A::next_value::<i32>(&mut __map) {
612 _serde::__private::Ok(__val) => __val,
613 _serde::__private::Err(__err) => {
614 return _serde::__private::Err(__err);
615 }
616 },
617 );
618 }
619 7usize => {
620 if _serde::__private::Option::is_some(&m_rootBoneIndex) {
621 return _serde::__private::Err(
622 <__A::Error as _serde::de::Error>::duplicate_field(
623 "rootBoneIndex",
624 ),
625 );
626 }
627 m_rootBoneIndex = _serde::__private::Some(
628 match __A::next_value::<i16>(&mut __map) {
629 _serde::__private::Ok(__val) => __val,
630 _serde::__private::Err(__err) => {
631 return _serde::__private::Err(__err);
632 }
633 },
634 );
635 }
636 8usize => {
637 if _serde::__private::Option::is_some(&m_otherBoneIndex) {
638 return _serde::__private::Err(
639 <__A::Error as _serde::de::Error>::duplicate_field(
640 "otherBoneIndex",
641 ),
642 );
643 }
644 m_otherBoneIndex = _serde::__private::Some(
645 match __A::next_value::<i16>(&mut __map) {
646 _serde::__private::Ok(__val) => __val,
647 _serde::__private::Err(__err) => {
648 return _serde::__private::Err(__err);
649 }
650 },
651 );
652 }
653 9usize => {
654 if _serde::__private::Option::is_some(&m_anotherBoneIndex) {
655 return _serde::__private::Err(
656 <__A::Error as _serde::de::Error>::duplicate_field(
657 "anotherBoneIndex",
658 ),
659 );
660 }
661 m_anotherBoneIndex = _serde::__private::Some(
662 match __A::next_value::<i16>(&mut __map) {
663 _serde::__private::Ok(__val) => __val,
664 _serde::__private::Err(__err) => {
665 return _serde::__private::Err(__err);
666 }
667 },
668 );
669 }
670 10usize => {
671 if _serde::__private::Option::is_some(&m_pelvisIndex) {
672 return _serde::__private::Err(
673 <__A::Error as _serde::de::Error>::duplicate_field(
674 "pelvisIndex",
675 ),
676 );
677 }
678 m_pelvisIndex = _serde::__private::Some(
679 match __A::next_value::<i16>(&mut __map) {
680 _serde::__private::Ok(__val) => __val,
681 _serde::__private::Err(__err) => {
682 return _serde::__private::Err(__err);
683 }
684 },
685 );
686 }
687 11usize => {
688 if _serde::__private::Option::is_some(&m_mode) {
689 return _serde::__private::Err(
690 <__A::Error as _serde::de::Error>::duplicate_field("mode"),
691 );
692 }
693 m_mode = _serde::__private::Some(
694 match __A::next_value::<Mode>(&mut __map) {
695 _serde::__private::Ok(__val) => __val,
696 _serde::__private::Err(__err) => {
697 return _serde::__private::Err(__err);
698 }
699 },
700 );
701 }
702 12usize => {
703 if _serde::__private::Option::is_some(&m_currentMatch) {
704 return _serde::__private::Err(
705 <__A::Error as _serde::de::Error>::duplicate_field(
706 "currentMatch",
707 ),
708 );
709 }
710 __A::pad(&mut __map, 3usize, 3usize)?;
711 m_currentMatch = _serde::__private::Some(
712 match __A::next_value::<i32>(&mut __map) {
713 _serde::__private::Ok(__val) => __val,
714 _serde::__private::Err(__err) => {
715 return _serde::__private::Err(__err);
716 }
717 },
718 );
719 }
720 13usize => {
721 if _serde::__private::Option::is_some(&m_bestMatch) {
722 return _serde::__private::Err(
723 <__A::Error as _serde::de::Error>::duplicate_field(
724 "bestMatch",
725 ),
726 );
727 }
728 m_bestMatch = _serde::__private::Some(
729 match __A::next_value::<i32>(&mut __map) {
730 _serde::__private::Ok(__val) => __val,
731 _serde::__private::Err(__err) => {
732 return _serde::__private::Err(__err);
733 }
734 },
735 );
736 }
737 14usize => {
738 if _serde::__private::Option::is_some(
739 &m_timeSinceBetterMatch,
740 ) {
741 return _serde::__private::Err(
742 <__A::Error as _serde::de::Error>::duplicate_field(
743 "timeSinceBetterMatch",
744 ),
745 );
746 }
747 m_timeSinceBetterMatch = _serde::__private::Some(
748 match __A::next_value::<f32>(&mut __map) {
749 _serde::__private::Ok(__val) => __val,
750 _serde::__private::Err(__err) => {
751 return _serde::__private::Err(__err);
752 }
753 },
754 );
755 }
756 15usize => {
757 if _serde::__private::Option::is_some(&m_error) {
758 return _serde::__private::Err(
759 <__A::Error as _serde::de::Error>::duplicate_field("error"),
760 );
761 }
762 m_error = _serde::__private::Some(
763 match __A::next_value::<f32>(&mut __map) {
764 _serde::__private::Ok(__val) => __val,
765 _serde::__private::Err(__err) => {
766 return _serde::__private::Err(__err);
767 }
768 },
769 );
770 }
771 16usize => {
772 if _serde::__private::Option::is_some(
773 &m_resetCurrentMatchLocalTime,
774 ) {
775 return _serde::__private::Err(
776 <__A::Error as _serde::de::Error>::duplicate_field(
777 "resetCurrentMatchLocalTime",
778 ),
779 );
780 }
781 m_resetCurrentMatchLocalTime = _serde::__private::Some(
782 match __A::next_value::<bool>(&mut __map) {
783 _serde::__private::Ok(__val) => __val,
784 _serde::__private::Err(__err) => {
785 return _serde::__private::Err(__err);
786 }
787 },
788 );
789 }
790 17usize => {
791 if _serde::__private::Option::is_some(
792 &m_poseMatchingUtility,
793 ) {
794 return _serde::__private::Err(
795 <__A::Error as _serde::de::Error>::duplicate_field(
796 "poseMatchingUtility",
797 ),
798 );
799 }
800 __A::pad(&mut __map, 3usize, 3usize)?;
801 m_poseMatchingUtility = _serde::__private::Some(
802 match __A::next_value::<Pointer>(&mut __map) {
803 _serde::__private::Ok(__val) => __val,
804 _serde::__private::Err(__err) => {
805 return _serde::__private::Err(__err);
806 }
807 },
808 );
809 }
810 _ => {}
811 }
812 }
813 __A::pad(&mut __map, 4usize, 0usize)?;
814 let m_worldFromModelRotation = match m_worldFromModelRotation {
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 "worldFromModelRotation",
820 ),
821 );
822 }
823 };
824 let m_blendSpeed = match m_blendSpeed {
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 "blendSpeed",
830 ),
831 );
832 }
833 };
834 let m_minSpeedToSwitch = match m_minSpeedToSwitch {
835 _serde::__private::Some(__field) => __field,
836 _serde::__private::None => {
837 return _serde::__private::Err(
838 <__A::Error as _serde::de::Error>::missing_field(
839 "minSpeedToSwitch",
840 ),
841 );
842 }
843 };
844 let m_minSwitchTimeNoError = match m_minSwitchTimeNoError {
845 _serde::__private::Some(__field) => __field,
846 _serde::__private::None => {
847 return _serde::__private::Err(
848 <__A::Error as _serde::de::Error>::missing_field(
849 "minSwitchTimeNoError",
850 ),
851 );
852 }
853 };
854 let m_minSwitchTimeFullError = match m_minSwitchTimeFullError {
855 _serde::__private::Some(__field) => __field,
856 _serde::__private::None => {
857 return _serde::__private::Err(
858 <__A::Error as _serde::de::Error>::missing_field(
859 "minSwitchTimeFullError",
860 ),
861 );
862 }
863 };
864 let m_startPlayingEventId = match m_startPlayingEventId {
865 _serde::__private::Some(__field) => __field,
866 _serde::__private::None => {
867 return _serde::__private::Err(
868 <__A::Error as _serde::de::Error>::missing_field(
869 "startPlayingEventId",
870 ),
871 );
872 }
873 };
874 let m_startMatchingEventId = match m_startMatchingEventId {
875 _serde::__private::Some(__field) => __field,
876 _serde::__private::None => {
877 return _serde::__private::Err(
878 <__A::Error as _serde::de::Error>::missing_field(
879 "startMatchingEventId",
880 ),
881 );
882 }
883 };
884 let m_rootBoneIndex = match m_rootBoneIndex {
885 _serde::__private::Some(__field) => __field,
886 _serde::__private::None => {
887 return _serde::__private::Err(
888 <__A::Error as _serde::de::Error>::missing_field(
889 "rootBoneIndex",
890 ),
891 );
892 }
893 };
894 let m_otherBoneIndex = match m_otherBoneIndex {
895 _serde::__private::Some(__field) => __field,
896 _serde::__private::None => {
897 return _serde::__private::Err(
898 <__A::Error as _serde::de::Error>::missing_field(
899 "otherBoneIndex",
900 ),
901 );
902 }
903 };
904 let m_anotherBoneIndex = match m_anotherBoneIndex {
905 _serde::__private::Some(__field) => __field,
906 _serde::__private::None => {
907 return _serde::__private::Err(
908 <__A::Error as _serde::de::Error>::missing_field(
909 "anotherBoneIndex",
910 ),
911 );
912 }
913 };
914 let m_pelvisIndex = match m_pelvisIndex {
915 _serde::__private::Some(__field) => __field,
916 _serde::__private::None => {
917 return _serde::__private::Err(
918 <__A::Error as _serde::de::Error>::missing_field(
919 "pelvisIndex",
920 ),
921 );
922 }
923 };
924 let m_mode = match m_mode {
925 _serde::__private::Some(__field) => __field,
926 _serde::__private::None => {
927 return _serde::__private::Err(
928 <__A::Error as _serde::de::Error>::missing_field("mode"),
929 );
930 }
931 };
932 let m_currentMatch = match m_currentMatch {
933 _serde::__private::Some(__field) => __field,
934 _serde::__private::None => {
935 return _serde::__private::Err(
936 <__A::Error as _serde::de::Error>::missing_field(
937 "currentMatch",
938 ),
939 );
940 }
941 };
942 let m_bestMatch = match m_bestMatch {
943 _serde::__private::Some(__field) => __field,
944 _serde::__private::None => {
945 return _serde::__private::Err(
946 <__A::Error as _serde::de::Error>::missing_field(
947 "bestMatch",
948 ),
949 );
950 }
951 };
952 let m_timeSinceBetterMatch = match m_timeSinceBetterMatch {
953 _serde::__private::Some(__field) => __field,
954 _serde::__private::None => {
955 return _serde::__private::Err(
956 <__A::Error as _serde::de::Error>::missing_field(
957 "timeSinceBetterMatch",
958 ),
959 );
960 }
961 };
962 let m_error = match m_error {
963 _serde::__private::Some(__field) => __field,
964 _serde::__private::None => {
965 return _serde::__private::Err(
966 <__A::Error as _serde::de::Error>::missing_field("error"),
967 );
968 }
969 };
970 let m_resetCurrentMatchLocalTime = match m_resetCurrentMatchLocalTime {
971 _serde::__private::Some(__field) => __field,
972 _serde::__private::None => {
973 return _serde::__private::Err(
974 <__A::Error as _serde::de::Error>::missing_field(
975 "resetCurrentMatchLocalTime",
976 ),
977 );
978 }
979 };
980 let m_poseMatchingUtility = match m_poseMatchingUtility {
981 _serde::__private::Some(__field) => __field,
982 _serde::__private::None => {
983 return _serde::__private::Err(
984 <__A::Error as _serde::de::Error>::missing_field(
985 "poseMatchingUtility",
986 ),
987 );
988 }
989 };
990 _serde::__private::Ok(hkbPoseMatchingGenerator {
991 __ptr,
992 parent,
993 m_worldFromModelRotation,
994 m_blendSpeed,
995 m_minSpeedToSwitch,
996 m_minSwitchTimeNoError,
997 m_minSwitchTimeFullError,
998 m_startPlayingEventId,
999 m_startMatchingEventId,
1000 m_rootBoneIndex,
1001 m_otherBoneIndex,
1002 m_anotherBoneIndex,
1003 m_pelvisIndex,
1004 m_mode,
1005 m_currentMatch,
1006 m_bestMatch,
1007 m_timeSinceBetterMatch,
1008 m_error,
1009 m_resetCurrentMatchLocalTime,
1010 m_poseMatchingUtility,
1011 })
1012 }
1013 #[allow(clippy::manual_unwrap_or_default)]
1014 fn visit_struct<__A>(
1015 self,
1016 mut __map: __A,
1017 ) -> _serde::__private::Result<Self::Value, __A::Error>
1018 where
1019 __A: _serde::de::MapAccess<'de>,
1020 {
1021 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
1022 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
1023 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
1024 let mut m_referencePoseWeightThreshold: _serde::__private::Option<
1025 f32,
1026 > = _serde::__private::None;
1027 let mut m_blendParameter: _serde::__private::Option<f32> = _serde::__private::None;
1028 let mut m_minCyclicBlendParameter: _serde::__private::Option<f32> = _serde::__private::None;
1029 let mut m_maxCyclicBlendParameter: _serde::__private::Option<f32> = _serde::__private::None;
1030 let mut m_indexOfSyncMasterChild: _serde::__private::Option<i16> = _serde::__private::None;
1031 let mut m_flags: _serde::__private::Option<i16> = _serde::__private::None;
1032 let mut m_subtractLastChild: _serde::__private::Option<bool> = _serde::__private::None;
1033 let mut m_children: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
1034 let mut m_worldFromModelRotation: _serde::__private::Option<
1035 Quaternion,
1036 > = _serde::__private::None;
1037 let mut m_blendSpeed: _serde::__private::Option<f32> = _serde::__private::None;
1038 let mut m_minSpeedToSwitch: _serde::__private::Option<f32> = _serde::__private::None;
1039 let mut m_minSwitchTimeNoError: _serde::__private::Option<f32> = _serde::__private::None;
1040 let mut m_minSwitchTimeFullError: _serde::__private::Option<f32> = _serde::__private::None;
1041 let mut m_startPlayingEventId: _serde::__private::Option<i32> = _serde::__private::None;
1042 let mut m_startMatchingEventId: _serde::__private::Option<i32> = _serde::__private::None;
1043 let mut m_rootBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
1044 let mut m_otherBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
1045 let mut m_anotherBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
1046 let mut m_pelvisIndex: _serde::__private::Option<i16> = _serde::__private::None;
1047 let mut m_mode: _serde::__private::Option<Mode> = _serde::__private::None;
1048 while let _serde::__private::Some(__key) = {
1049 __A::next_key::<__Field>(&mut __map)?
1050 } {
1051 match __key {
1052 __Field::m_variableBindingSet => {
1053 #[cfg(
1054 any(feature = "strict", feature = "ignore_duplicates")
1055 )]
1056 if _serde::__private::Option::is_some(
1057 &m_variableBindingSet,
1058 ) {
1059 #[cfg(feature = "ignore_duplicates")]
1060 {
1061 __A::skip_value(&mut __map)?;
1062 continue;
1063 }
1064 #[cfg(feature = "strict")]
1065 return _serde::__private::Err(
1066 <__A::Error as _serde::de::Error>::duplicate_field(
1067 "variableBindingSet",
1068 ),
1069 );
1070 }
1071 m_variableBindingSet = _serde::__private::Some(
1072 match __A::next_value::<Pointer>(&mut __map) {
1073 _serde::__private::Ok(__val) => __val,
1074 _serde::__private::Err(__err) => {
1075 return _serde::__private::Err(__err);
1076 }
1077 },
1078 );
1079 }
1080 __Field::m_userData => {
1081 #[cfg(
1082 any(feature = "strict", feature = "ignore_duplicates")
1083 )]
1084 if _serde::__private::Option::is_some(&m_userData) {
1085 #[cfg(feature = "ignore_duplicates")]
1086 {
1087 __A::skip_value(&mut __map)?;
1088 continue;
1089 }
1090 #[cfg(feature = "strict")]
1091 return _serde::__private::Err(
1092 <__A::Error as _serde::de::Error>::duplicate_field(
1093 "userData",
1094 ),
1095 );
1096 }
1097 m_userData = _serde::__private::Some(
1098 match __A::next_value::<Ulong>(&mut __map) {
1099 _serde::__private::Ok(__val) => __val,
1100 _serde::__private::Err(__err) => {
1101 return _serde::__private::Err(__err);
1102 }
1103 },
1104 );
1105 }
1106 __Field::m_name => {
1107 #[cfg(
1108 any(feature = "strict", feature = "ignore_duplicates")
1109 )]
1110 if _serde::__private::Option::is_some(&m_name) {
1111 #[cfg(feature = "ignore_duplicates")]
1112 {
1113 __A::skip_value(&mut __map)?;
1114 continue;
1115 }
1116 #[cfg(feature = "strict")]
1117 return _serde::__private::Err(
1118 <__A::Error as _serde::de::Error>::duplicate_field("name"),
1119 );
1120 }
1121 m_name = _serde::__private::Some(
1122 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1123 _serde::__private::Ok(__val) => __val,
1124 _serde::__private::Err(__err) => {
1125 return _serde::__private::Err(__err);
1126 }
1127 },
1128 );
1129 }
1130 __Field::m_referencePoseWeightThreshold => {
1131 #[cfg(
1132 any(feature = "strict", feature = "ignore_duplicates")
1133 )]
1134 if _serde::__private::Option::is_some(
1135 &m_referencePoseWeightThreshold,
1136 ) {
1137 #[cfg(feature = "ignore_duplicates")]
1138 {
1139 __A::skip_value(&mut __map)?;
1140 continue;
1141 }
1142 #[cfg(feature = "strict")]
1143 return _serde::__private::Err(
1144 <__A::Error as _serde::de::Error>::duplicate_field(
1145 "referencePoseWeightThreshold",
1146 ),
1147 );
1148 }
1149 m_referencePoseWeightThreshold = _serde::__private::Some(
1150 match __A::next_value::<f32>(&mut __map) {
1151 _serde::__private::Ok(__val) => __val,
1152 _serde::__private::Err(__err) => {
1153 return _serde::__private::Err(__err);
1154 }
1155 },
1156 );
1157 }
1158 __Field::m_blendParameter => {
1159 #[cfg(
1160 any(feature = "strict", feature = "ignore_duplicates")
1161 )]
1162 if _serde::__private::Option::is_some(&m_blendParameter) {
1163 #[cfg(feature = "ignore_duplicates")]
1164 {
1165 __A::skip_value(&mut __map)?;
1166 continue;
1167 }
1168 #[cfg(feature = "strict")]
1169 return _serde::__private::Err(
1170 <__A::Error as _serde::de::Error>::duplicate_field(
1171 "blendParameter",
1172 ),
1173 );
1174 }
1175 m_blendParameter = _serde::__private::Some(
1176 match __A::next_value::<f32>(&mut __map) {
1177 _serde::__private::Ok(__val) => __val,
1178 _serde::__private::Err(__err) => {
1179 return _serde::__private::Err(__err);
1180 }
1181 },
1182 );
1183 }
1184 __Field::m_minCyclicBlendParameter => {
1185 #[cfg(
1186 any(feature = "strict", feature = "ignore_duplicates")
1187 )]
1188 if _serde::__private::Option::is_some(
1189 &m_minCyclicBlendParameter,
1190 ) {
1191 #[cfg(feature = "ignore_duplicates")]
1192 {
1193 __A::skip_value(&mut __map)?;
1194 continue;
1195 }
1196 #[cfg(feature = "strict")]
1197 return _serde::__private::Err(
1198 <__A::Error as _serde::de::Error>::duplicate_field(
1199 "minCyclicBlendParameter",
1200 ),
1201 );
1202 }
1203 m_minCyclicBlendParameter = _serde::__private::Some(
1204 match __A::next_value::<f32>(&mut __map) {
1205 _serde::__private::Ok(__val) => __val,
1206 _serde::__private::Err(__err) => {
1207 return _serde::__private::Err(__err);
1208 }
1209 },
1210 );
1211 }
1212 __Field::m_maxCyclicBlendParameter => {
1213 #[cfg(
1214 any(feature = "strict", feature = "ignore_duplicates")
1215 )]
1216 if _serde::__private::Option::is_some(
1217 &m_maxCyclicBlendParameter,
1218 ) {
1219 #[cfg(feature = "ignore_duplicates")]
1220 {
1221 __A::skip_value(&mut __map)?;
1222 continue;
1223 }
1224 #[cfg(feature = "strict")]
1225 return _serde::__private::Err(
1226 <__A::Error as _serde::de::Error>::duplicate_field(
1227 "maxCyclicBlendParameter",
1228 ),
1229 );
1230 }
1231 m_maxCyclicBlendParameter = _serde::__private::Some(
1232 match __A::next_value::<f32>(&mut __map) {
1233 _serde::__private::Ok(__val) => __val,
1234 _serde::__private::Err(__err) => {
1235 return _serde::__private::Err(__err);
1236 }
1237 },
1238 );
1239 }
1240 __Field::m_indexOfSyncMasterChild => {
1241 #[cfg(
1242 any(feature = "strict", feature = "ignore_duplicates")
1243 )]
1244 if _serde::__private::Option::is_some(
1245 &m_indexOfSyncMasterChild,
1246 ) {
1247 #[cfg(feature = "ignore_duplicates")]
1248 {
1249 __A::skip_value(&mut __map)?;
1250 continue;
1251 }
1252 #[cfg(feature = "strict")]
1253 return _serde::__private::Err(
1254 <__A::Error as _serde::de::Error>::duplicate_field(
1255 "indexOfSyncMasterChild",
1256 ),
1257 );
1258 }
1259 m_indexOfSyncMasterChild = _serde::__private::Some(
1260 match __A::next_value::<i16>(&mut __map) {
1261 _serde::__private::Ok(__val) => __val,
1262 _serde::__private::Err(__err) => {
1263 return _serde::__private::Err(__err);
1264 }
1265 },
1266 );
1267 }
1268 __Field::m_flags => {
1269 #[cfg(
1270 any(feature = "strict", feature = "ignore_duplicates")
1271 )]
1272 if _serde::__private::Option::is_some(&m_flags) {
1273 #[cfg(feature = "ignore_duplicates")]
1274 {
1275 __A::skip_value(&mut __map)?;
1276 continue;
1277 }
1278 #[cfg(feature = "strict")]
1279 return _serde::__private::Err(
1280 <__A::Error as _serde::de::Error>::duplicate_field("flags"),
1281 );
1282 }
1283 m_flags = _serde::__private::Some(
1284 match __A::next_value::<i16>(&mut __map) {
1285 _serde::__private::Ok(__val) => __val,
1286 _serde::__private::Err(__err) => {
1287 return _serde::__private::Err(__err);
1288 }
1289 },
1290 );
1291 }
1292 __Field::m_subtractLastChild => {
1293 #[cfg(
1294 any(feature = "strict", feature = "ignore_duplicates")
1295 )]
1296 if _serde::__private::Option::is_some(
1297 &m_subtractLastChild,
1298 ) {
1299 #[cfg(feature = "ignore_duplicates")]
1300 {
1301 __A::skip_value(&mut __map)?;
1302 continue;
1303 }
1304 #[cfg(feature = "strict")]
1305 return _serde::__private::Err(
1306 <__A::Error as _serde::de::Error>::duplicate_field(
1307 "subtractLastChild",
1308 ),
1309 );
1310 }
1311 m_subtractLastChild = _serde::__private::Some(
1312 match __A::next_value::<bool>(&mut __map) {
1313 _serde::__private::Ok(__val) => __val,
1314 _serde::__private::Err(__err) => {
1315 return _serde::__private::Err(__err);
1316 }
1317 },
1318 );
1319 }
1320 __Field::m_children => {
1321 #[cfg(
1322 any(feature = "strict", feature = "ignore_duplicates")
1323 )]
1324 if _serde::__private::Option::is_some(&m_children) {
1325 #[cfg(feature = "ignore_duplicates")]
1326 {
1327 __A::skip_value(&mut __map)?;
1328 continue;
1329 }
1330 #[cfg(feature = "strict")]
1331 return _serde::__private::Err(
1332 <__A::Error as _serde::de::Error>::duplicate_field(
1333 "children",
1334 ),
1335 );
1336 }
1337 m_children = _serde::__private::Some(
1338 match __A::next_value::<Vec<Pointer>>(&mut __map) {
1339 _serde::__private::Ok(__val) => __val,
1340 _serde::__private::Err(__err) => {
1341 return _serde::__private::Err(__err);
1342 }
1343 },
1344 );
1345 }
1346 __Field::m_worldFromModelRotation => {
1347 #[cfg(
1348 any(feature = "strict", feature = "ignore_duplicates")
1349 )]
1350 if _serde::__private::Option::is_some(
1351 &m_worldFromModelRotation,
1352 ) {
1353 #[cfg(feature = "ignore_duplicates")]
1354 {
1355 __A::skip_value(&mut __map)?;
1356 continue;
1357 }
1358 #[cfg(feature = "strict")]
1359 return _serde::__private::Err(
1360 <__A::Error as _serde::de::Error>::duplicate_field(
1361 "worldFromModelRotation",
1362 ),
1363 );
1364 }
1365 m_worldFromModelRotation = _serde::__private::Some(
1366 match __A::next_value::<Quaternion>(&mut __map) {
1367 _serde::__private::Ok(__val) => __val,
1368 _serde::__private::Err(__err) => {
1369 return _serde::__private::Err(__err);
1370 }
1371 },
1372 );
1373 }
1374 __Field::m_blendSpeed => {
1375 #[cfg(
1376 any(feature = "strict", feature = "ignore_duplicates")
1377 )]
1378 if _serde::__private::Option::is_some(&m_blendSpeed) {
1379 #[cfg(feature = "ignore_duplicates")]
1380 {
1381 __A::skip_value(&mut __map)?;
1382 continue;
1383 }
1384 #[cfg(feature = "strict")]
1385 return _serde::__private::Err(
1386 <__A::Error as _serde::de::Error>::duplicate_field(
1387 "blendSpeed",
1388 ),
1389 );
1390 }
1391 m_blendSpeed = _serde::__private::Some(
1392 match __A::next_value::<f32>(&mut __map) {
1393 _serde::__private::Ok(__val) => __val,
1394 _serde::__private::Err(__err) => {
1395 return _serde::__private::Err(__err);
1396 }
1397 },
1398 );
1399 }
1400 __Field::m_minSpeedToSwitch => {
1401 #[cfg(
1402 any(feature = "strict", feature = "ignore_duplicates")
1403 )]
1404 if _serde::__private::Option::is_some(&m_minSpeedToSwitch) {
1405 #[cfg(feature = "ignore_duplicates")]
1406 {
1407 __A::skip_value(&mut __map)?;
1408 continue;
1409 }
1410 #[cfg(feature = "strict")]
1411 return _serde::__private::Err(
1412 <__A::Error as _serde::de::Error>::duplicate_field(
1413 "minSpeedToSwitch",
1414 ),
1415 );
1416 }
1417 m_minSpeedToSwitch = _serde::__private::Some(
1418 match __A::next_value::<f32>(&mut __map) {
1419 _serde::__private::Ok(__val) => __val,
1420 _serde::__private::Err(__err) => {
1421 return _serde::__private::Err(__err);
1422 }
1423 },
1424 );
1425 }
1426 __Field::m_minSwitchTimeNoError => {
1427 #[cfg(
1428 any(feature = "strict", feature = "ignore_duplicates")
1429 )]
1430 if _serde::__private::Option::is_some(
1431 &m_minSwitchTimeNoError,
1432 ) {
1433 #[cfg(feature = "ignore_duplicates")]
1434 {
1435 __A::skip_value(&mut __map)?;
1436 continue;
1437 }
1438 #[cfg(feature = "strict")]
1439 return _serde::__private::Err(
1440 <__A::Error as _serde::de::Error>::duplicate_field(
1441 "minSwitchTimeNoError",
1442 ),
1443 );
1444 }
1445 m_minSwitchTimeNoError = _serde::__private::Some(
1446 match __A::next_value::<f32>(&mut __map) {
1447 _serde::__private::Ok(__val) => __val,
1448 _serde::__private::Err(__err) => {
1449 return _serde::__private::Err(__err);
1450 }
1451 },
1452 );
1453 }
1454 __Field::m_minSwitchTimeFullError => {
1455 #[cfg(
1456 any(feature = "strict", feature = "ignore_duplicates")
1457 )]
1458 if _serde::__private::Option::is_some(
1459 &m_minSwitchTimeFullError,
1460 ) {
1461 #[cfg(feature = "ignore_duplicates")]
1462 {
1463 __A::skip_value(&mut __map)?;
1464 continue;
1465 }
1466 #[cfg(feature = "strict")]
1467 return _serde::__private::Err(
1468 <__A::Error as _serde::de::Error>::duplicate_field(
1469 "minSwitchTimeFullError",
1470 ),
1471 );
1472 }
1473 m_minSwitchTimeFullError = _serde::__private::Some(
1474 match __A::next_value::<f32>(&mut __map) {
1475 _serde::__private::Ok(__val) => __val,
1476 _serde::__private::Err(__err) => {
1477 return _serde::__private::Err(__err);
1478 }
1479 },
1480 );
1481 }
1482 __Field::m_startPlayingEventId => {
1483 #[cfg(
1484 any(feature = "strict", feature = "ignore_duplicates")
1485 )]
1486 if _serde::__private::Option::is_some(
1487 &m_startPlayingEventId,
1488 ) {
1489 #[cfg(feature = "ignore_duplicates")]
1490 {
1491 __A::skip_value(&mut __map)?;
1492 continue;
1493 }
1494 #[cfg(feature = "strict")]
1495 return _serde::__private::Err(
1496 <__A::Error as _serde::de::Error>::duplicate_field(
1497 "startPlayingEventId",
1498 ),
1499 );
1500 }
1501 m_startPlayingEventId = _serde::__private::Some(
1502 match __A::next_value::<i32>(&mut __map) {
1503 _serde::__private::Ok(__val) => __val,
1504 _serde::__private::Err(__err) => {
1505 return _serde::__private::Err(__err);
1506 }
1507 },
1508 );
1509 }
1510 __Field::m_startMatchingEventId => {
1511 #[cfg(
1512 any(feature = "strict", feature = "ignore_duplicates")
1513 )]
1514 if _serde::__private::Option::is_some(
1515 &m_startMatchingEventId,
1516 ) {
1517 #[cfg(feature = "ignore_duplicates")]
1518 {
1519 __A::skip_value(&mut __map)?;
1520 continue;
1521 }
1522 #[cfg(feature = "strict")]
1523 return _serde::__private::Err(
1524 <__A::Error as _serde::de::Error>::duplicate_field(
1525 "startMatchingEventId",
1526 ),
1527 );
1528 }
1529 m_startMatchingEventId = _serde::__private::Some(
1530 match __A::next_value::<i32>(&mut __map) {
1531 _serde::__private::Ok(__val) => __val,
1532 _serde::__private::Err(__err) => {
1533 return _serde::__private::Err(__err);
1534 }
1535 },
1536 );
1537 }
1538 __Field::m_rootBoneIndex => {
1539 #[cfg(
1540 any(feature = "strict", feature = "ignore_duplicates")
1541 )]
1542 if _serde::__private::Option::is_some(&m_rootBoneIndex) {
1543 #[cfg(feature = "ignore_duplicates")]
1544 {
1545 __A::skip_value(&mut __map)?;
1546 continue;
1547 }
1548 #[cfg(feature = "strict")]
1549 return _serde::__private::Err(
1550 <__A::Error as _serde::de::Error>::duplicate_field(
1551 "rootBoneIndex",
1552 ),
1553 );
1554 }
1555 m_rootBoneIndex = _serde::__private::Some(
1556 match __A::next_value::<i16>(&mut __map) {
1557 _serde::__private::Ok(__val) => __val,
1558 _serde::__private::Err(__err) => {
1559 return _serde::__private::Err(__err);
1560 }
1561 },
1562 );
1563 }
1564 __Field::m_otherBoneIndex => {
1565 #[cfg(
1566 any(feature = "strict", feature = "ignore_duplicates")
1567 )]
1568 if _serde::__private::Option::is_some(&m_otherBoneIndex) {
1569 #[cfg(feature = "ignore_duplicates")]
1570 {
1571 __A::skip_value(&mut __map)?;
1572 continue;
1573 }
1574 #[cfg(feature = "strict")]
1575 return _serde::__private::Err(
1576 <__A::Error as _serde::de::Error>::duplicate_field(
1577 "otherBoneIndex",
1578 ),
1579 );
1580 }
1581 m_otherBoneIndex = _serde::__private::Some(
1582 match __A::next_value::<i16>(&mut __map) {
1583 _serde::__private::Ok(__val) => __val,
1584 _serde::__private::Err(__err) => {
1585 return _serde::__private::Err(__err);
1586 }
1587 },
1588 );
1589 }
1590 __Field::m_anotherBoneIndex => {
1591 #[cfg(
1592 any(feature = "strict", feature = "ignore_duplicates")
1593 )]
1594 if _serde::__private::Option::is_some(&m_anotherBoneIndex) {
1595 #[cfg(feature = "ignore_duplicates")]
1596 {
1597 __A::skip_value(&mut __map)?;
1598 continue;
1599 }
1600 #[cfg(feature = "strict")]
1601 return _serde::__private::Err(
1602 <__A::Error as _serde::de::Error>::duplicate_field(
1603 "anotherBoneIndex",
1604 ),
1605 );
1606 }
1607 m_anotherBoneIndex = _serde::__private::Some(
1608 match __A::next_value::<i16>(&mut __map) {
1609 _serde::__private::Ok(__val) => __val,
1610 _serde::__private::Err(__err) => {
1611 return _serde::__private::Err(__err);
1612 }
1613 },
1614 );
1615 }
1616 __Field::m_pelvisIndex => {
1617 #[cfg(
1618 any(feature = "strict", feature = "ignore_duplicates")
1619 )]
1620 if _serde::__private::Option::is_some(&m_pelvisIndex) {
1621 #[cfg(feature = "ignore_duplicates")]
1622 {
1623 __A::skip_value(&mut __map)?;
1624 continue;
1625 }
1626 #[cfg(feature = "strict")]
1627 return _serde::__private::Err(
1628 <__A::Error as _serde::de::Error>::duplicate_field(
1629 "pelvisIndex",
1630 ),
1631 );
1632 }
1633 m_pelvisIndex = _serde::__private::Some(
1634 match __A::next_value::<i16>(&mut __map) {
1635 _serde::__private::Ok(__val) => __val,
1636 _serde::__private::Err(__err) => {
1637 return _serde::__private::Err(__err);
1638 }
1639 },
1640 );
1641 }
1642 __Field::m_mode => {
1643 #[cfg(
1644 any(feature = "strict", feature = "ignore_duplicates")
1645 )]
1646 if _serde::__private::Option::is_some(&m_mode) {
1647 #[cfg(feature = "ignore_duplicates")]
1648 {
1649 __A::skip_value(&mut __map)?;
1650 continue;
1651 }
1652 #[cfg(feature = "strict")]
1653 return _serde::__private::Err(
1654 <__A::Error as _serde::de::Error>::duplicate_field("mode"),
1655 );
1656 }
1657 m_mode = _serde::__private::Some(
1658 match __A::next_value::<Mode>(&mut __map) {
1659 _serde::__private::Ok(__val) => __val,
1660 _serde::__private::Err(__err) => {
1661 return _serde::__private::Err(__err);
1662 }
1663 },
1664 );
1665 }
1666 _ => __A::skip_value(&mut __map)?,
1667 }
1668 }
1669 let m_variableBindingSet = match m_variableBindingSet {
1670 _serde::__private::Some(__field) => __field,
1671 _serde::__private::None => {
1672 #[cfg(feature = "strict")]
1673 return _serde::__private::Err(
1674 <__A::Error as _serde::de::Error>::missing_field(
1675 "variableBindingSet",
1676 ),
1677 );
1678 #[cfg(not(feature = "strict"))] Default::default()
1679 }
1680 };
1681 let m_userData = match m_userData {
1682 _serde::__private::Some(__field) => __field,
1683 _serde::__private::None => {
1684 #[cfg(feature = "strict")]
1685 return _serde::__private::Err(
1686 <__A::Error as _serde::de::Error>::missing_field("userData"),
1687 );
1688 #[cfg(not(feature = "strict"))] Default::default()
1689 }
1690 };
1691 let m_name = match m_name {
1692 _serde::__private::Some(__field) => __field,
1693 _serde::__private::None => {
1694 #[cfg(feature = "strict")]
1695 return _serde::__private::Err(
1696 <__A::Error as _serde::de::Error>::missing_field("name"),
1697 );
1698 #[cfg(not(feature = "strict"))] Default::default()
1699 }
1700 };
1701 let m_referencePoseWeightThreshold = match m_referencePoseWeightThreshold {
1702 _serde::__private::Some(__field) => __field,
1703 _serde::__private::None => {
1704 #[cfg(feature = "strict")]
1705 return _serde::__private::Err(
1706 <__A::Error as _serde::de::Error>::missing_field(
1707 "referencePoseWeightThreshold",
1708 ),
1709 );
1710 #[cfg(not(feature = "strict"))] Default::default()
1711 }
1712 };
1713 let m_blendParameter = match m_blendParameter {
1714 _serde::__private::Some(__field) => __field,
1715 _serde::__private::None => {
1716 #[cfg(feature = "strict")]
1717 return _serde::__private::Err(
1718 <__A::Error as _serde::de::Error>::missing_field(
1719 "blendParameter",
1720 ),
1721 );
1722 #[cfg(not(feature = "strict"))] Default::default()
1723 }
1724 };
1725 let m_minCyclicBlendParameter = match m_minCyclicBlendParameter {
1726 _serde::__private::Some(__field) => __field,
1727 _serde::__private::None => {
1728 #[cfg(feature = "strict")]
1729 return _serde::__private::Err(
1730 <__A::Error as _serde::de::Error>::missing_field(
1731 "minCyclicBlendParameter",
1732 ),
1733 );
1734 #[cfg(not(feature = "strict"))] Default::default()
1735 }
1736 };
1737 let m_maxCyclicBlendParameter = match m_maxCyclicBlendParameter {
1738 _serde::__private::Some(__field) => __field,
1739 _serde::__private::None => {
1740 #[cfg(feature = "strict")]
1741 return _serde::__private::Err(
1742 <__A::Error as _serde::de::Error>::missing_field(
1743 "maxCyclicBlendParameter",
1744 ),
1745 );
1746 #[cfg(not(feature = "strict"))] Default::default()
1747 }
1748 };
1749 let m_indexOfSyncMasterChild = match m_indexOfSyncMasterChild {
1750 _serde::__private::Some(__field) => __field,
1751 _serde::__private::None => {
1752 #[cfg(feature = "strict")]
1753 return _serde::__private::Err(
1754 <__A::Error as _serde::de::Error>::missing_field(
1755 "indexOfSyncMasterChild",
1756 ),
1757 );
1758 #[cfg(not(feature = "strict"))] Default::default()
1759 }
1760 };
1761 let m_flags = match m_flags {
1762 _serde::__private::Some(__field) => __field,
1763 _serde::__private::None => {
1764 #[cfg(feature = "strict")]
1765 return _serde::__private::Err(
1766 <__A::Error as _serde::de::Error>::missing_field("flags"),
1767 );
1768 #[cfg(not(feature = "strict"))] Default::default()
1769 }
1770 };
1771 let m_subtractLastChild = match m_subtractLastChild {
1772 _serde::__private::Some(__field) => __field,
1773 _serde::__private::None => {
1774 #[cfg(feature = "strict")]
1775 return _serde::__private::Err(
1776 <__A::Error as _serde::de::Error>::missing_field(
1777 "subtractLastChild",
1778 ),
1779 );
1780 #[cfg(not(feature = "strict"))] Default::default()
1781 }
1782 };
1783 let m_children = match m_children {
1784 _serde::__private::Some(__field) => __field,
1785 _serde::__private::None => {
1786 #[cfg(feature = "strict")]
1787 return _serde::__private::Err(
1788 <__A::Error as _serde::de::Error>::missing_field("children"),
1789 );
1790 #[cfg(not(feature = "strict"))] Default::default()
1791 }
1792 };
1793 let m_worldFromModelRotation = match m_worldFromModelRotation {
1794 _serde::__private::Some(__field) => __field,
1795 _serde::__private::None => {
1796 #[cfg(feature = "strict")]
1797 return _serde::__private::Err(
1798 <__A::Error as _serde::de::Error>::missing_field(
1799 "worldFromModelRotation",
1800 ),
1801 );
1802 #[cfg(not(feature = "strict"))] Default::default()
1803 }
1804 };
1805 let m_blendSpeed = match m_blendSpeed {
1806 _serde::__private::Some(__field) => __field,
1807 _serde::__private::None => {
1808 #[cfg(feature = "strict")]
1809 return _serde::__private::Err(
1810 <__A::Error as _serde::de::Error>::missing_field(
1811 "blendSpeed",
1812 ),
1813 );
1814 #[cfg(not(feature = "strict"))] Default::default()
1815 }
1816 };
1817 let m_minSpeedToSwitch = match m_minSpeedToSwitch {
1818 _serde::__private::Some(__field) => __field,
1819 _serde::__private::None => {
1820 #[cfg(feature = "strict")]
1821 return _serde::__private::Err(
1822 <__A::Error as _serde::de::Error>::missing_field(
1823 "minSpeedToSwitch",
1824 ),
1825 );
1826 #[cfg(not(feature = "strict"))] Default::default()
1827 }
1828 };
1829 let m_minSwitchTimeNoError = match m_minSwitchTimeNoError {
1830 _serde::__private::Some(__field) => __field,
1831 _serde::__private::None => {
1832 #[cfg(feature = "strict")]
1833 return _serde::__private::Err(
1834 <__A::Error as _serde::de::Error>::missing_field(
1835 "minSwitchTimeNoError",
1836 ),
1837 );
1838 #[cfg(not(feature = "strict"))] Default::default()
1839 }
1840 };
1841 let m_minSwitchTimeFullError = match m_minSwitchTimeFullError {
1842 _serde::__private::Some(__field) => __field,
1843 _serde::__private::None => {
1844 #[cfg(feature = "strict")]
1845 return _serde::__private::Err(
1846 <__A::Error as _serde::de::Error>::missing_field(
1847 "minSwitchTimeFullError",
1848 ),
1849 );
1850 #[cfg(not(feature = "strict"))] Default::default()
1851 }
1852 };
1853 let m_startPlayingEventId = match m_startPlayingEventId {
1854 _serde::__private::Some(__field) => __field,
1855 _serde::__private::None => {
1856 #[cfg(feature = "strict")]
1857 return _serde::__private::Err(
1858 <__A::Error as _serde::de::Error>::missing_field(
1859 "startPlayingEventId",
1860 ),
1861 );
1862 #[cfg(not(feature = "strict"))] Default::default()
1863 }
1864 };
1865 let m_startMatchingEventId = match m_startMatchingEventId {
1866 _serde::__private::Some(__field) => __field,
1867 _serde::__private::None => {
1868 #[cfg(feature = "strict")]
1869 return _serde::__private::Err(
1870 <__A::Error as _serde::de::Error>::missing_field(
1871 "startMatchingEventId",
1872 ),
1873 );
1874 #[cfg(not(feature = "strict"))] Default::default()
1875 }
1876 };
1877 let m_rootBoneIndex = match m_rootBoneIndex {
1878 _serde::__private::Some(__field) => __field,
1879 _serde::__private::None => {
1880 #[cfg(feature = "strict")]
1881 return _serde::__private::Err(
1882 <__A::Error as _serde::de::Error>::missing_field(
1883 "rootBoneIndex",
1884 ),
1885 );
1886 #[cfg(not(feature = "strict"))] Default::default()
1887 }
1888 };
1889 let m_otherBoneIndex = match m_otherBoneIndex {
1890 _serde::__private::Some(__field) => __field,
1891 _serde::__private::None => {
1892 #[cfg(feature = "strict")]
1893 return _serde::__private::Err(
1894 <__A::Error as _serde::de::Error>::missing_field(
1895 "otherBoneIndex",
1896 ),
1897 );
1898 #[cfg(not(feature = "strict"))] Default::default()
1899 }
1900 };
1901 let m_anotherBoneIndex = match m_anotherBoneIndex {
1902 _serde::__private::Some(__field) => __field,
1903 _serde::__private::None => {
1904 #[cfg(feature = "strict")]
1905 return _serde::__private::Err(
1906 <__A::Error as _serde::de::Error>::missing_field(
1907 "anotherBoneIndex",
1908 ),
1909 );
1910 #[cfg(not(feature = "strict"))] Default::default()
1911 }
1912 };
1913 let m_pelvisIndex = match m_pelvisIndex {
1914 _serde::__private::Some(__field) => __field,
1915 _serde::__private::None => {
1916 #[cfg(feature = "strict")]
1917 return _serde::__private::Err(
1918 <__A::Error as _serde::de::Error>::missing_field(
1919 "pelvisIndex",
1920 ),
1921 );
1922 #[cfg(not(feature = "strict"))] Default::default()
1923 }
1924 };
1925 let m_mode = match m_mode {
1926 _serde::__private::Some(__field) => __field,
1927 _serde::__private::None => {
1928 #[cfg(feature = "strict")]
1929 return _serde::__private::Err(
1930 <__A::Error as _serde::de::Error>::missing_field("mode"),
1931 );
1932 #[cfg(not(feature = "strict"))] Default::default()
1933 }
1934 };
1935 let __ptr = None;
1936 let parent = hkBaseObject { __ptr };
1937 let parent = hkReferencedObject {
1938 __ptr,
1939 parent,
1940 ..Default::default()
1941 };
1942 let parent = hkbBindable {
1943 __ptr,
1944 parent,
1945 m_variableBindingSet,
1946 ..Default::default()
1947 };
1948 let parent = hkbNode {
1949 __ptr,
1950 parent,
1951 m_userData,
1952 m_name,
1953 ..Default::default()
1954 };
1955 let parent = hkbGenerator { __ptr, parent };
1956 let parent = hkbBlenderGenerator {
1957 __ptr,
1958 parent,
1959 m_referencePoseWeightThreshold,
1960 m_blendParameter,
1961 m_minCyclicBlendParameter,
1962 m_maxCyclicBlendParameter,
1963 m_indexOfSyncMasterChild,
1964 m_flags,
1965 m_subtractLastChild,
1966 m_children,
1967 ..Default::default()
1968 };
1969 let __ptr = __A::class_ptr(&mut __map);
1970 _serde::__private::Ok(hkbPoseMatchingGenerator {
1971 __ptr,
1972 parent,
1973 m_worldFromModelRotation,
1974 m_blendSpeed,
1975 m_minSpeedToSwitch,
1976 m_minSwitchTimeNoError,
1977 m_minSwitchTimeFullError,
1978 m_startPlayingEventId,
1979 m_startMatchingEventId,
1980 m_rootBoneIndex,
1981 m_otherBoneIndex,
1982 m_anotherBoneIndex,
1983 m_pelvisIndex,
1984 m_mode,
1985 ..Default::default()
1986 })
1987 }
1988 }
1989 const FIELDS: &[&str] = &[
1990 "worldFromModelRotation",
1991 "blendSpeed",
1992 "minSpeedToSwitch",
1993 "minSwitchTimeNoError",
1994 "minSwitchTimeFullError",
1995 "startPlayingEventId",
1996 "startMatchingEventId",
1997 "rootBoneIndex",
1998 "otherBoneIndex",
1999 "anotherBoneIndex",
2000 "pelvisIndex",
2001 "mode",
2002 "currentMatch",
2003 "bestMatch",
2004 "timeSinceBetterMatch",
2005 "error",
2006 "resetCurrentMatchLocalTime",
2007 "poseMatchingUtility",
2008 ];
2009 _serde::Deserializer::deserialize_struct(
2010 deserializer,
2011 "hkbPoseMatchingGenerator",
2012 FIELDS,
2013 __hkbPoseMatchingGeneratorVisitor {
2014 marker: _serde::__private::PhantomData::<hkbPoseMatchingGenerator>,
2015 lifetime: _serde::__private::PhantomData,
2016 },
2017 )
2018 }
2019 }
2020};
2021#[allow(non_upper_case_globals, non_snake_case)]
2024#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
2025#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
2026#[derive(
2027 Debug,
2028 Clone,
2029 Default,
2030 PartialEq,
2031 Eq,
2032 PartialOrd,
2033 Ord,
2034 num_derive::ToPrimitive,
2035 num_derive::FromPrimitive,
2036)]
2037pub enum Mode {
2038 #[default]
2039 MODE_MATCH = 0isize,
2040 MODE_PLAY = 1isize,
2041}
2042const _: () = {
2043 use havok_serde as __serde;
2044 impl __serde::Serialize for Mode {
2045 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
2046 where
2047 S: __serde::ser::Serializer,
2048 {
2049 let mut __serializer = __serializer.serialize_enum_flags()?;
2050 match self {
2051 Self::MODE_MATCH => __serializer.serialize_field("MODE_MATCH", &0u64),
2052 Self::MODE_PLAY => __serializer.serialize_field("MODE_PLAY", &1u64),
2053 }?;
2054 use num_traits::ToPrimitive as _;
2055 let num = self.to_i8().ok_or(S::Error::custom("Failed enum Mode to_i8"))?;
2056 __serializer.serialize_bits(&num)?;
2057 __serializer.end()
2058 }
2059 }
2060};
2061#[doc(hidden)]
2062#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
2063const _: () = {
2064 #[allow(unused_extern_crates, clippy::useless_attribute)]
2065 extern crate havok_serde as _serde;
2066 #[automatically_derived]
2067 impl<'de> _serde::Deserialize<'de> for Mode {
2068 fn deserialize<__D>(
2069 __deserializer: __D,
2070 ) -> _serde::__private::Result<Self, __D::Error>
2071 where
2072 __D: _serde::Deserializer<'de>,
2073 {
2074 #[allow(non_camel_case_types)]
2075 #[doc(hidden)]
2076 enum __Field {
2077 __field0,
2078 __field1,
2079 }
2080 #[doc(hidden)]
2081 struct __FieldVisitor;
2082 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
2083 type Value = __Field;
2084 fn expecting(
2085 &self,
2086 __formatter: &mut _serde::__private::Formatter,
2087 ) -> _serde::__private::fmt::Result {
2088 _serde::__private::Formatter::write_str(
2089 __formatter,
2090 "variant identifier",
2091 )
2092 }
2093 fn visit_int8<__E>(
2094 self,
2095 __value: i8,
2096 ) -> _serde::__private::Result<Self::Value, __E>
2097 where
2098 __E: _serde::de::Error,
2099 {
2100 match __value {
2101 0i8 => _serde::__private::Ok(__Field::__field0),
2102 1i8 => _serde::__private::Ok(__Field::__field1),
2103 _ => {
2104 _serde::__private::Err(
2105 _serde::de::Error::invalid_value(
2106 _serde::de::Unexpected::Int8(__value),
2107 &"value(i8) of variant is one of 0, 1",
2108 ),
2109 )
2110 }
2111 }
2112 }
2113 fn visit_stringptr<__E>(
2114 self,
2115 __value: StringPtr<'de>,
2116 ) -> _serde::__private::Result<Self::Value, __E>
2117 where
2118 __E: _serde::de::Error,
2119 {
2120 if let Some(__value) = __value.into_inner() {
2121 match __value.as_ref() {
2122 v if v == "0" || v.eq_ignore_ascii_case("MODE_MATCH") => {
2123 _serde::__private::Ok(__Field::__field0)
2124 }
2125 v if v == "1" || v.eq_ignore_ascii_case("MODE_PLAY") => {
2126 _serde::__private::Ok(__Field::__field1)
2127 }
2128 _ => {
2129 _serde::__private::Err(
2130 _serde::de::Error::unknown_variant(&__value, VARIANTS),
2131 )
2132 }
2133 }
2134 } else {
2135 _serde::__private::Err(
2136 _serde::de::Error::unknown_variant("None", VARIANTS),
2137 )
2138 }
2139 }
2140 }
2141 impl<'de> _serde::Deserialize<'de> for __Field {
2142 #[inline]
2143 fn deserialize<__D>(
2144 __deserializer: __D,
2145 ) -> _serde::__private::Result<Self, __D::Error>
2146 where
2147 __D: _serde::Deserializer<'de>,
2148 {
2149 _serde::Deserializer::deserialize_identifier(
2150 __deserializer,
2151 _serde::de::ReadEnumSize::Int8,
2152 __FieldVisitor,
2153 )
2154 }
2155 }
2156 #[doc(hidden)]
2157 struct __Visitor<'de> {
2158 marker: _serde::__private::PhantomData<Mode>,
2159 lifetime: _serde::__private::PhantomData<&'de ()>,
2160 }
2161 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
2162 type Value = Mode;
2163 fn expecting(
2164 &self,
2165 __formatter: &mut _serde::__private::Formatter,
2166 ) -> _serde::__private::fmt::Result {
2167 _serde::__private::Formatter::write_str(__formatter, "enum Mode")
2168 }
2169 fn visit_enum<__A>(
2170 self,
2171 __data: __A,
2172 ) -> _serde::__private::Result<Self::Value, __A::Error>
2173 where
2174 __A: _serde::de::EnumAccess<'de>,
2175 {
2176 match _serde::de::EnumAccess::variant(__data)? {
2177 (__Field::__field0, __variant) => {
2178 _serde::de::VariantAccess::unit_variant(__variant)?;
2179 _serde::__private::Ok(Mode::MODE_MATCH)
2180 }
2181 (__Field::__field1, __variant) => {
2182 _serde::de::VariantAccess::unit_variant(__variant)?;
2183 _serde::__private::Ok(Mode::MODE_PLAY)
2184 }
2185 }
2186 }
2187 }
2188 #[doc(hidden)]
2189 const VARIANTS: &'static [&'static str] = &["MODE_MATCH", "MODE_PLAY"];
2190 _serde::Deserializer::deserialize_enum(
2191 __deserializer,
2192 "Mode",
2193 VARIANTS,
2194 __Visitor {
2195 marker: _serde::__private::PhantomData::<Mode>,
2196 lifetime: _serde::__private::PhantomData,
2197 },
2198 )
2199 }
2200 }
2201};