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 hkbTwistModifier<'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: hkbModifier<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "axisOfRotation"))]
36 #[cfg_attr(feature = "serde", serde(rename = "axisOfRotation"))]
37 pub m_axisOfRotation: Vector4,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "twistAngle"))]
43 #[cfg_attr(feature = "serde", serde(rename = "twistAngle"))]
44 pub m_twistAngle: f32,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "startBoneIndex"))]
50 #[cfg_attr(feature = "serde", serde(rename = "startBoneIndex"))]
51 pub m_startBoneIndex: i16,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "endBoneIndex"))]
57 #[cfg_attr(feature = "serde", serde(rename = "endBoneIndex"))]
58 pub m_endBoneIndex: i16,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "setAngleMethod"))]
64 #[cfg_attr(feature = "serde", serde(rename = "setAngleMethod"))]
65 pub m_setAngleMethod: SetAngleMethod,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "rotationAxisCoordinates"))]
71 #[cfg_attr(feature = "serde", serde(rename = "rotationAxisCoordinates"))]
72 pub m_rotationAxisCoordinates: RotationAxisCoordinates,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "isAdditive"))]
78 #[cfg_attr(feature = "serde", serde(rename = "isAdditive"))]
79 pub m_isAdditive: bool,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "boneChainIndices"))]
86 #[cfg_attr(feature = "serde", serde(rename = "boneChainIndices"))]
87 pub m_boneChainIndices: Vec<()>,
88 #[cfg_attr(feature = "json_schema", schemars(rename = "parentBoneIndices"))]
94 #[cfg_attr(feature = "serde", serde(rename = "parentBoneIndices"))]
95 pub m_parentBoneIndices: Vec<()>,
96}
97const _: () = {
98 use havok_serde as _serde;
99 impl<'a> _serde::HavokClass for hkbTwistModifier<'a> {
100 #[inline]
101 fn name(&self) -> &'static str {
102 "hkbTwistModifier"
103 }
104 #[inline]
105 fn signature(&self) -> _serde::__private::Signature {
106 _serde::__private::Signature::new(0xb6b76b32)
107 }
108 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
109 fn deps_indexes(&self) -> Vec<usize> {
110 let mut v = Vec::new();
111 v.push(self.parent.parent.parent.m_variableBindingSet.get());
112 v
113 }
114 }
115 impl<'a> _serde::Serialize for hkbTwistModifier<'a> {
116 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
117 where
118 S: _serde::ser::Serializer,
119 {
120 let class_meta = self
121 .__ptr
122 .map(|name| (name, _serde::__private::Signature::new(0xb6b76b32)));
123 let mut serializer = __serializer
124 .serialize_struct("hkbTwistModifier", class_meta, (112u64, 144u64))?;
125 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
126 serializer
127 .skip_field(
128 "memSizeAndFlags",
129 &self.parent.parent.parent.parent.m_memSizeAndFlags,
130 )?;
131 serializer
132 .skip_field(
133 "referenceCount",
134 &self.parent.parent.parent.parent.m_referenceCount,
135 )?;
136 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
137 serializer
138 .serialize_field(
139 "variableBindingSet",
140 &self.parent.parent.parent.m_variableBindingSet,
141 )?;
142 serializer
143 .skip_array_field(
144 "cachedBindables",
145 &self.parent.parent.parent.m_cachedBindables,
146 TypeSize::NonPtr,
147 )?;
148 serializer
149 .skip_field(
150 "areBindablesCached",
151 &self.parent.parent.parent.m_areBindablesCached,
152 )?;
153 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
154 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
155 serializer.serialize_field("name", &self.parent.parent.m_name)?;
156 serializer.skip_field("id", &self.parent.parent.m_id)?;
157 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
158 serializer
159 .skip_fixed_array_field(
160 "padNode",
161 self.parent.parent.m_padNode.as_slice(),
162 TypeSize::NonPtr,
163 )?;
164 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
165 serializer.serialize_field("enable", &self.parent.m_enable)?;
166 serializer
167 .skip_fixed_array_field(
168 "padModifier",
169 self.parent.m_padModifier.as_slice(),
170 TypeSize::NonPtr,
171 )?;
172 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
173 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
174 serializer.serialize_field("axisOfRotation", &self.m_axisOfRotation)?;
175 serializer.serialize_field("twistAngle", &self.m_twistAngle)?;
176 serializer.serialize_field("startBoneIndex", &self.m_startBoneIndex)?;
177 serializer.serialize_field("endBoneIndex", &self.m_endBoneIndex)?;
178 serializer.serialize_field("setAngleMethod", &self.m_setAngleMethod)?;
179 serializer
180 .serialize_field(
181 "rotationAxisCoordinates",
182 &self.m_rotationAxisCoordinates,
183 )?;
184 serializer.serialize_field("isAdditive", &self.m_isAdditive)?;
185 serializer.pad_field([0u8; 1usize].as_slice(), [0u8; 5usize].as_slice())?;
186 serializer
187 .skip_array_field(
188 "boneChainIndices",
189 &self.m_boneChainIndices,
190 TypeSize::NonPtr,
191 )?;
192 serializer
193 .skip_array_field(
194 "parentBoneIndices",
195 &self.m_parentBoneIndices,
196 TypeSize::NonPtr,
197 )?;
198 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 0usize].as_slice())?;
199 serializer.end()
200 }
201 }
202};
203#[doc(hidden)]
204#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
205const _: () = {
206 use havok_serde as _serde;
207 #[automatically_derived]
208 impl<'de> _serde::Deserialize<'de> for hkbTwistModifier<'de> {
209 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
210 where
211 __D: _serde::Deserializer<'de>,
212 {
213 #[allow(non_camel_case_types)]
214 enum __Field {
215 m_variableBindingSet,
216 m_userData,
217 m_name,
218 m_enable,
219 m_axisOfRotation,
220 m_twistAngle,
221 m_startBoneIndex,
222 m_endBoneIndex,
223 m_setAngleMethod,
224 m_rotationAxisCoordinates,
225 m_isAdditive,
226 __ignore,
227 }
228 struct __FieldVisitor;
229 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
230 type Value = __Field;
231 fn expecting(
232 &self,
233 __formatter: &mut core::fmt::Formatter,
234 ) -> core::fmt::Result {
235 core::fmt::Formatter::write_str(__formatter, "field identifier")
236 }
237 #[allow(clippy::match_single_binding)]
239 #[allow(clippy::reversed_empty_ranges)]
240 #[allow(clippy::single_match)]
241 fn visit_key<__E>(
242 self,
243 __value: &str,
244 ) -> core::result::Result<Self::Value, __E>
245 where
246 __E: _serde::de::Error,
247 {
248 match __value {
249 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
250 "userData" => Ok(__Field::m_userData),
251 "name" => Ok(__Field::m_name),
252 "enable" => Ok(__Field::m_enable),
253 "axisOfRotation" => Ok(__Field::m_axisOfRotation),
254 "twistAngle" => Ok(__Field::m_twistAngle),
255 "startBoneIndex" => Ok(__Field::m_startBoneIndex),
256 "endBoneIndex" => Ok(__Field::m_endBoneIndex),
257 "setAngleMethod" => Ok(__Field::m_setAngleMethod),
258 "rotationAxisCoordinates" => {
259 Ok(__Field::m_rotationAxisCoordinates)
260 }
261 "isAdditive" => Ok(__Field::m_isAdditive),
262 _ => Ok(__Field::__ignore),
263 }
264 }
265 }
266 impl<'de> _serde::Deserialize<'de> for __Field {
267 #[inline]
268 fn deserialize<__D>(
269 __deserializer: __D,
270 ) -> core::result::Result<Self, __D::Error>
271 where
272 __D: _serde::Deserializer<'de>,
273 {
274 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
275 }
276 }
277 struct __hkbTwistModifierVisitor<'de> {
278 marker: _serde::__private::PhantomData<hkbTwistModifier<'de>>,
279 lifetime: _serde::__private::PhantomData<&'de ()>,
280 }
281 #[allow(clippy::match_single_binding)]
282 #[allow(clippy::reversed_empty_ranges)]
283 #[allow(clippy::single_match)]
284 impl<'de> _serde::de::Visitor<'de> for __hkbTwistModifierVisitor<'de> {
285 type Value = hkbTwistModifier<'de>;
286 fn expecting(
287 &self,
288 __formatter: &mut core::fmt::Formatter,
289 ) -> core::fmt::Result {
290 core::fmt::Formatter::write_str(
291 __formatter,
292 "struct hkbTwistModifier",
293 )
294 }
295 fn visit_struct_for_bytes<__A>(
296 self,
297 mut __map: __A,
298 ) -> _serde::__private::Result<Self::Value, __A::Error>
299 where
300 __A: _serde::de::MapAccess<'de>,
301 {
302 let __ptr = __A::class_ptr(&mut __map);
303 let parent = __A::parent_value(&mut __map)?;
304 let mut m_axisOfRotation: _serde::__private::Option<Vector4> = _serde::__private::None;
305 let mut m_twistAngle: _serde::__private::Option<f32> = _serde::__private::None;
306 let mut m_startBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
307 let mut m_endBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
308 let mut m_setAngleMethod: _serde::__private::Option<
309 SetAngleMethod,
310 > = _serde::__private::None;
311 let mut m_rotationAxisCoordinates: _serde::__private::Option<
312 RotationAxisCoordinates,
313 > = _serde::__private::None;
314 let mut m_isAdditive: _serde::__private::Option<bool> = _serde::__private::None;
315 let mut m_boneChainIndices: _serde::__private::Option<Vec<()>> = _serde::__private::None;
316 let mut m_parentBoneIndices: _serde::__private::Option<Vec<()>> = _serde::__private::None;
317 for i in 0..9usize {
318 match i {
319 0usize => {
320 if _serde::__private::Option::is_some(&m_axisOfRotation) {
321 return _serde::__private::Err(
322 <__A::Error as _serde::de::Error>::duplicate_field(
323 "axisOfRotation",
324 ),
325 );
326 }
327 __A::pad(&mut __map, 4usize, 0usize)?;
328 m_axisOfRotation = _serde::__private::Some(
329 match __A::next_value::<Vector4>(&mut __map) {
330 _serde::__private::Ok(__val) => __val,
331 _serde::__private::Err(__err) => {
332 return _serde::__private::Err(__err);
333 }
334 },
335 );
336 }
337 1usize => {
338 if _serde::__private::Option::is_some(&m_twistAngle) {
339 return _serde::__private::Err(
340 <__A::Error as _serde::de::Error>::duplicate_field(
341 "twistAngle",
342 ),
343 );
344 }
345 m_twistAngle = _serde::__private::Some(
346 match __A::next_value::<f32>(&mut __map) {
347 _serde::__private::Ok(__val) => __val,
348 _serde::__private::Err(__err) => {
349 return _serde::__private::Err(__err);
350 }
351 },
352 );
353 }
354 2usize => {
355 if _serde::__private::Option::is_some(&m_startBoneIndex) {
356 return _serde::__private::Err(
357 <__A::Error as _serde::de::Error>::duplicate_field(
358 "startBoneIndex",
359 ),
360 );
361 }
362 m_startBoneIndex = _serde::__private::Some(
363 match __A::next_value::<i16>(&mut __map) {
364 _serde::__private::Ok(__val) => __val,
365 _serde::__private::Err(__err) => {
366 return _serde::__private::Err(__err);
367 }
368 },
369 );
370 }
371 3usize => {
372 if _serde::__private::Option::is_some(&m_endBoneIndex) {
373 return _serde::__private::Err(
374 <__A::Error as _serde::de::Error>::duplicate_field(
375 "endBoneIndex",
376 ),
377 );
378 }
379 m_endBoneIndex = _serde::__private::Some(
380 match __A::next_value::<i16>(&mut __map) {
381 _serde::__private::Ok(__val) => __val,
382 _serde::__private::Err(__err) => {
383 return _serde::__private::Err(__err);
384 }
385 },
386 );
387 }
388 4usize => {
389 if _serde::__private::Option::is_some(&m_setAngleMethod) {
390 return _serde::__private::Err(
391 <__A::Error as _serde::de::Error>::duplicate_field(
392 "setAngleMethod",
393 ),
394 );
395 }
396 m_setAngleMethod = _serde::__private::Some(
397 match __A::next_value::<SetAngleMethod>(&mut __map) {
398 _serde::__private::Ok(__val) => __val,
399 _serde::__private::Err(__err) => {
400 return _serde::__private::Err(__err);
401 }
402 },
403 );
404 }
405 5usize => {
406 if _serde::__private::Option::is_some(
407 &m_rotationAxisCoordinates,
408 ) {
409 return _serde::__private::Err(
410 <__A::Error as _serde::de::Error>::duplicate_field(
411 "rotationAxisCoordinates",
412 ),
413 );
414 }
415 m_rotationAxisCoordinates = _serde::__private::Some(
416 match __A::next_value::<
417 RotationAxisCoordinates,
418 >(&mut __map) {
419 _serde::__private::Ok(__val) => __val,
420 _serde::__private::Err(__err) => {
421 return _serde::__private::Err(__err);
422 }
423 },
424 );
425 }
426 6usize => {
427 if _serde::__private::Option::is_some(&m_isAdditive) {
428 return _serde::__private::Err(
429 <__A::Error as _serde::de::Error>::duplicate_field(
430 "isAdditive",
431 ),
432 );
433 }
434 m_isAdditive = _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 7usize => {
444 if _serde::__private::Option::is_some(&m_boneChainIndices) {
445 return _serde::__private::Err(
446 <__A::Error as _serde::de::Error>::duplicate_field(
447 "boneChainIndices",
448 ),
449 );
450 }
451 __A::pad(&mut __map, 1usize, 5usize)?;
452 m_boneChainIndices = _serde::__private::Some(
453 match __A::next_value::<Vec<()>>(&mut __map) {
454 _serde::__private::Ok(__val) => __val,
455 _serde::__private::Err(__err) => {
456 return _serde::__private::Err(__err);
457 }
458 },
459 );
460 }
461 8usize => {
462 if _serde::__private::Option::is_some(
463 &m_parentBoneIndices,
464 ) {
465 return _serde::__private::Err(
466 <__A::Error as _serde::de::Error>::duplicate_field(
467 "parentBoneIndices",
468 ),
469 );
470 }
471 m_parentBoneIndices = _serde::__private::Some(
472 match __A::next_value::<Vec<()>>(&mut __map) {
473 _serde::__private::Ok(__val) => __val,
474 _serde::__private::Err(__err) => {
475 return _serde::__private::Err(__err);
476 }
477 },
478 );
479 }
480 _ => {}
481 }
482 }
483 __A::pad(&mut __map, 12usize, 0usize)?;
484 let m_axisOfRotation = match m_axisOfRotation {
485 _serde::__private::Some(__field) => __field,
486 _serde::__private::None => {
487 return _serde::__private::Err(
488 <__A::Error as _serde::de::Error>::missing_field(
489 "axisOfRotation",
490 ),
491 );
492 }
493 };
494 let m_twistAngle = match m_twistAngle {
495 _serde::__private::Some(__field) => __field,
496 _serde::__private::None => {
497 return _serde::__private::Err(
498 <__A::Error as _serde::de::Error>::missing_field(
499 "twistAngle",
500 ),
501 );
502 }
503 };
504 let m_startBoneIndex = match m_startBoneIndex {
505 _serde::__private::Some(__field) => __field,
506 _serde::__private::None => {
507 return _serde::__private::Err(
508 <__A::Error as _serde::de::Error>::missing_field(
509 "startBoneIndex",
510 ),
511 );
512 }
513 };
514 let m_endBoneIndex = match m_endBoneIndex {
515 _serde::__private::Some(__field) => __field,
516 _serde::__private::None => {
517 return _serde::__private::Err(
518 <__A::Error as _serde::de::Error>::missing_field(
519 "endBoneIndex",
520 ),
521 );
522 }
523 };
524 let m_setAngleMethod = match m_setAngleMethod {
525 _serde::__private::Some(__field) => __field,
526 _serde::__private::None => {
527 return _serde::__private::Err(
528 <__A::Error as _serde::de::Error>::missing_field(
529 "setAngleMethod",
530 ),
531 );
532 }
533 };
534 let m_rotationAxisCoordinates = match m_rotationAxisCoordinates {
535 _serde::__private::Some(__field) => __field,
536 _serde::__private::None => {
537 return _serde::__private::Err(
538 <__A::Error as _serde::de::Error>::missing_field(
539 "rotationAxisCoordinates",
540 ),
541 );
542 }
543 };
544 let m_isAdditive = match m_isAdditive {
545 _serde::__private::Some(__field) => __field,
546 _serde::__private::None => {
547 return _serde::__private::Err(
548 <__A::Error as _serde::de::Error>::missing_field(
549 "isAdditive",
550 ),
551 );
552 }
553 };
554 let m_boneChainIndices = match m_boneChainIndices {
555 _serde::__private::Some(__field) => __field,
556 _serde::__private::None => {
557 return _serde::__private::Err(
558 <__A::Error as _serde::de::Error>::missing_field(
559 "boneChainIndices",
560 ),
561 );
562 }
563 };
564 let m_parentBoneIndices = match m_parentBoneIndices {
565 _serde::__private::Some(__field) => __field,
566 _serde::__private::None => {
567 return _serde::__private::Err(
568 <__A::Error as _serde::de::Error>::missing_field(
569 "parentBoneIndices",
570 ),
571 );
572 }
573 };
574 _serde::__private::Ok(hkbTwistModifier {
575 __ptr,
576 parent,
577 m_axisOfRotation,
578 m_twistAngle,
579 m_startBoneIndex,
580 m_endBoneIndex,
581 m_setAngleMethod,
582 m_rotationAxisCoordinates,
583 m_isAdditive,
584 m_boneChainIndices,
585 m_parentBoneIndices,
586 })
587 }
588 #[allow(clippy::manual_unwrap_or_default)]
589 fn visit_struct<__A>(
590 self,
591 mut __map: __A,
592 ) -> _serde::__private::Result<Self::Value, __A::Error>
593 where
594 __A: _serde::de::MapAccess<'de>,
595 {
596 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
597 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
598 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
599 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
600 let mut m_axisOfRotation: _serde::__private::Option<Vector4> = _serde::__private::None;
601 let mut m_twistAngle: _serde::__private::Option<f32> = _serde::__private::None;
602 let mut m_startBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
603 let mut m_endBoneIndex: _serde::__private::Option<i16> = _serde::__private::None;
604 let mut m_setAngleMethod: _serde::__private::Option<
605 SetAngleMethod,
606 > = _serde::__private::None;
607 let mut m_rotationAxisCoordinates: _serde::__private::Option<
608 RotationAxisCoordinates,
609 > = _serde::__private::None;
610 let mut m_isAdditive: _serde::__private::Option<bool> = _serde::__private::None;
611 while let _serde::__private::Some(__key) = {
612 __A::next_key::<__Field>(&mut __map)?
613 } {
614 match __key {
615 __Field::m_variableBindingSet => {
616 #[cfg(
617 any(feature = "strict", feature = "ignore_duplicates")
618 )]
619 if _serde::__private::Option::is_some(
620 &m_variableBindingSet,
621 ) {
622 #[cfg(feature = "ignore_duplicates")]
623 {
624 __A::skip_value(&mut __map)?;
625 continue;
626 }
627 #[cfg(feature = "strict")]
628 return _serde::__private::Err(
629 <__A::Error as _serde::de::Error>::duplicate_field(
630 "variableBindingSet",
631 ),
632 );
633 }
634 m_variableBindingSet = _serde::__private::Some(
635 match __A::next_value::<Pointer>(&mut __map) {
636 _serde::__private::Ok(__val) => __val,
637 _serde::__private::Err(__err) => {
638 return _serde::__private::Err(__err);
639 }
640 },
641 );
642 }
643 __Field::m_userData => {
644 #[cfg(
645 any(feature = "strict", feature = "ignore_duplicates")
646 )]
647 if _serde::__private::Option::is_some(&m_userData) {
648 #[cfg(feature = "ignore_duplicates")]
649 {
650 __A::skip_value(&mut __map)?;
651 continue;
652 }
653 #[cfg(feature = "strict")]
654 return _serde::__private::Err(
655 <__A::Error as _serde::de::Error>::duplicate_field(
656 "userData",
657 ),
658 );
659 }
660 m_userData = _serde::__private::Some(
661 match __A::next_value::<Ulong>(&mut __map) {
662 _serde::__private::Ok(__val) => __val,
663 _serde::__private::Err(__err) => {
664 return _serde::__private::Err(__err);
665 }
666 },
667 );
668 }
669 __Field::m_name => {
670 #[cfg(
671 any(feature = "strict", feature = "ignore_duplicates")
672 )]
673 if _serde::__private::Option::is_some(&m_name) {
674 #[cfg(feature = "ignore_duplicates")]
675 {
676 __A::skip_value(&mut __map)?;
677 continue;
678 }
679 #[cfg(feature = "strict")]
680 return _serde::__private::Err(
681 <__A::Error as _serde::de::Error>::duplicate_field("name"),
682 );
683 }
684 m_name = _serde::__private::Some(
685 match __A::next_value::<StringPtr<'de>>(&mut __map) {
686 _serde::__private::Ok(__val) => __val,
687 _serde::__private::Err(__err) => {
688 return _serde::__private::Err(__err);
689 }
690 },
691 );
692 }
693 __Field::m_enable => {
694 #[cfg(
695 any(feature = "strict", feature = "ignore_duplicates")
696 )]
697 if _serde::__private::Option::is_some(&m_enable) {
698 #[cfg(feature = "ignore_duplicates")]
699 {
700 __A::skip_value(&mut __map)?;
701 continue;
702 }
703 #[cfg(feature = "strict")]
704 return _serde::__private::Err(
705 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
706 );
707 }
708 m_enable = _serde::__private::Some(
709 match __A::next_value::<bool>(&mut __map) {
710 _serde::__private::Ok(__val) => __val,
711 _serde::__private::Err(__err) => {
712 return _serde::__private::Err(__err);
713 }
714 },
715 );
716 }
717 __Field::m_axisOfRotation => {
718 #[cfg(
719 any(feature = "strict", feature = "ignore_duplicates")
720 )]
721 if _serde::__private::Option::is_some(&m_axisOfRotation) {
722 #[cfg(feature = "ignore_duplicates")]
723 {
724 __A::skip_value(&mut __map)?;
725 continue;
726 }
727 #[cfg(feature = "strict")]
728 return _serde::__private::Err(
729 <__A::Error as _serde::de::Error>::duplicate_field(
730 "axisOfRotation",
731 ),
732 );
733 }
734 m_axisOfRotation = _serde::__private::Some(
735 match __A::next_value::<Vector4>(&mut __map) {
736 _serde::__private::Ok(__val) => __val,
737 _serde::__private::Err(__err) => {
738 return _serde::__private::Err(__err);
739 }
740 },
741 );
742 }
743 __Field::m_twistAngle => {
744 #[cfg(
745 any(feature = "strict", feature = "ignore_duplicates")
746 )]
747 if _serde::__private::Option::is_some(&m_twistAngle) {
748 #[cfg(feature = "ignore_duplicates")]
749 {
750 __A::skip_value(&mut __map)?;
751 continue;
752 }
753 #[cfg(feature = "strict")]
754 return _serde::__private::Err(
755 <__A::Error as _serde::de::Error>::duplicate_field(
756 "twistAngle",
757 ),
758 );
759 }
760 m_twistAngle = _serde::__private::Some(
761 match __A::next_value::<f32>(&mut __map) {
762 _serde::__private::Ok(__val) => __val,
763 _serde::__private::Err(__err) => {
764 return _serde::__private::Err(__err);
765 }
766 },
767 );
768 }
769 __Field::m_startBoneIndex => {
770 #[cfg(
771 any(feature = "strict", feature = "ignore_duplicates")
772 )]
773 if _serde::__private::Option::is_some(&m_startBoneIndex) {
774 #[cfg(feature = "ignore_duplicates")]
775 {
776 __A::skip_value(&mut __map)?;
777 continue;
778 }
779 #[cfg(feature = "strict")]
780 return _serde::__private::Err(
781 <__A::Error as _serde::de::Error>::duplicate_field(
782 "startBoneIndex",
783 ),
784 );
785 }
786 m_startBoneIndex = _serde::__private::Some(
787 match __A::next_value::<i16>(&mut __map) {
788 _serde::__private::Ok(__val) => __val,
789 _serde::__private::Err(__err) => {
790 return _serde::__private::Err(__err);
791 }
792 },
793 );
794 }
795 __Field::m_endBoneIndex => {
796 #[cfg(
797 any(feature = "strict", feature = "ignore_duplicates")
798 )]
799 if _serde::__private::Option::is_some(&m_endBoneIndex) {
800 #[cfg(feature = "ignore_duplicates")]
801 {
802 __A::skip_value(&mut __map)?;
803 continue;
804 }
805 #[cfg(feature = "strict")]
806 return _serde::__private::Err(
807 <__A::Error as _serde::de::Error>::duplicate_field(
808 "endBoneIndex",
809 ),
810 );
811 }
812 m_endBoneIndex = _serde::__private::Some(
813 match __A::next_value::<i16>(&mut __map) {
814 _serde::__private::Ok(__val) => __val,
815 _serde::__private::Err(__err) => {
816 return _serde::__private::Err(__err);
817 }
818 },
819 );
820 }
821 __Field::m_setAngleMethod => {
822 #[cfg(
823 any(feature = "strict", feature = "ignore_duplicates")
824 )]
825 if _serde::__private::Option::is_some(&m_setAngleMethod) {
826 #[cfg(feature = "ignore_duplicates")]
827 {
828 __A::skip_value(&mut __map)?;
829 continue;
830 }
831 #[cfg(feature = "strict")]
832 return _serde::__private::Err(
833 <__A::Error as _serde::de::Error>::duplicate_field(
834 "setAngleMethod",
835 ),
836 );
837 }
838 m_setAngleMethod = _serde::__private::Some(
839 match __A::next_value::<SetAngleMethod>(&mut __map) {
840 _serde::__private::Ok(__val) => __val,
841 _serde::__private::Err(__err) => {
842 return _serde::__private::Err(__err);
843 }
844 },
845 );
846 }
847 __Field::m_rotationAxisCoordinates => {
848 #[cfg(
849 any(feature = "strict", feature = "ignore_duplicates")
850 )]
851 if _serde::__private::Option::is_some(
852 &m_rotationAxisCoordinates,
853 ) {
854 #[cfg(feature = "ignore_duplicates")]
855 {
856 __A::skip_value(&mut __map)?;
857 continue;
858 }
859 #[cfg(feature = "strict")]
860 return _serde::__private::Err(
861 <__A::Error as _serde::de::Error>::duplicate_field(
862 "rotationAxisCoordinates",
863 ),
864 );
865 }
866 m_rotationAxisCoordinates = _serde::__private::Some(
867 match __A::next_value::<
868 RotationAxisCoordinates,
869 >(&mut __map) {
870 _serde::__private::Ok(__val) => __val,
871 _serde::__private::Err(__err) => {
872 return _serde::__private::Err(__err);
873 }
874 },
875 );
876 }
877 __Field::m_isAdditive => {
878 #[cfg(
879 any(feature = "strict", feature = "ignore_duplicates")
880 )]
881 if _serde::__private::Option::is_some(&m_isAdditive) {
882 #[cfg(feature = "ignore_duplicates")]
883 {
884 __A::skip_value(&mut __map)?;
885 continue;
886 }
887 #[cfg(feature = "strict")]
888 return _serde::__private::Err(
889 <__A::Error as _serde::de::Error>::duplicate_field(
890 "isAdditive",
891 ),
892 );
893 }
894 m_isAdditive = _serde::__private::Some(
895 match __A::next_value::<bool>(&mut __map) {
896 _serde::__private::Ok(__val) => __val,
897 _serde::__private::Err(__err) => {
898 return _serde::__private::Err(__err);
899 }
900 },
901 );
902 }
903 _ => __A::skip_value(&mut __map)?,
904 }
905 }
906 let m_variableBindingSet = match m_variableBindingSet {
907 _serde::__private::Some(__field) => __field,
908 _serde::__private::None => {
909 #[cfg(feature = "strict")]
910 return _serde::__private::Err(
911 <__A::Error as _serde::de::Error>::missing_field(
912 "variableBindingSet",
913 ),
914 );
915 #[cfg(not(feature = "strict"))] Default::default()
916 }
917 };
918 let m_userData = match m_userData {
919 _serde::__private::Some(__field) => __field,
920 _serde::__private::None => {
921 #[cfg(feature = "strict")]
922 return _serde::__private::Err(
923 <__A::Error as _serde::de::Error>::missing_field("userData"),
924 );
925 #[cfg(not(feature = "strict"))] Default::default()
926 }
927 };
928 let m_name = match m_name {
929 _serde::__private::Some(__field) => __field,
930 _serde::__private::None => {
931 #[cfg(feature = "strict")]
932 return _serde::__private::Err(
933 <__A::Error as _serde::de::Error>::missing_field("name"),
934 );
935 #[cfg(not(feature = "strict"))] Default::default()
936 }
937 };
938 let m_enable = match m_enable {
939 _serde::__private::Some(__field) => __field,
940 _serde::__private::None => {
941 #[cfg(feature = "strict")]
942 return _serde::__private::Err(
943 <__A::Error as _serde::de::Error>::missing_field("enable"),
944 );
945 #[cfg(not(feature = "strict"))] Default::default()
946 }
947 };
948 let m_axisOfRotation = match m_axisOfRotation {
949 _serde::__private::Some(__field) => __field,
950 _serde::__private::None => {
951 #[cfg(feature = "strict")]
952 return _serde::__private::Err(
953 <__A::Error as _serde::de::Error>::missing_field(
954 "axisOfRotation",
955 ),
956 );
957 #[cfg(not(feature = "strict"))] Default::default()
958 }
959 };
960 let m_twistAngle = match m_twistAngle {
961 _serde::__private::Some(__field) => __field,
962 _serde::__private::None => {
963 #[cfg(feature = "strict")]
964 return _serde::__private::Err(
965 <__A::Error as _serde::de::Error>::missing_field(
966 "twistAngle",
967 ),
968 );
969 #[cfg(not(feature = "strict"))] Default::default()
970 }
971 };
972 let m_startBoneIndex = match m_startBoneIndex {
973 _serde::__private::Some(__field) => __field,
974 _serde::__private::None => {
975 #[cfg(feature = "strict")]
976 return _serde::__private::Err(
977 <__A::Error as _serde::de::Error>::missing_field(
978 "startBoneIndex",
979 ),
980 );
981 #[cfg(not(feature = "strict"))] Default::default()
982 }
983 };
984 let m_endBoneIndex = match m_endBoneIndex {
985 _serde::__private::Some(__field) => __field,
986 _serde::__private::None => {
987 #[cfg(feature = "strict")]
988 return _serde::__private::Err(
989 <__A::Error as _serde::de::Error>::missing_field(
990 "endBoneIndex",
991 ),
992 );
993 #[cfg(not(feature = "strict"))] Default::default()
994 }
995 };
996 let m_setAngleMethod = match m_setAngleMethod {
997 _serde::__private::Some(__field) => __field,
998 _serde::__private::None => {
999 #[cfg(feature = "strict")]
1000 return _serde::__private::Err(
1001 <__A::Error as _serde::de::Error>::missing_field(
1002 "setAngleMethod",
1003 ),
1004 );
1005 #[cfg(not(feature = "strict"))] Default::default()
1006 }
1007 };
1008 let m_rotationAxisCoordinates = match m_rotationAxisCoordinates {
1009 _serde::__private::Some(__field) => __field,
1010 _serde::__private::None => {
1011 #[cfg(feature = "strict")]
1012 return _serde::__private::Err(
1013 <__A::Error as _serde::de::Error>::missing_field(
1014 "rotationAxisCoordinates",
1015 ),
1016 );
1017 #[cfg(not(feature = "strict"))] Default::default()
1018 }
1019 };
1020 let m_isAdditive = match m_isAdditive {
1021 _serde::__private::Some(__field) => __field,
1022 _serde::__private::None => {
1023 #[cfg(feature = "strict")]
1024 return _serde::__private::Err(
1025 <__A::Error as _serde::de::Error>::missing_field(
1026 "isAdditive",
1027 ),
1028 );
1029 #[cfg(not(feature = "strict"))] Default::default()
1030 }
1031 };
1032 let __ptr = None;
1033 let parent = hkBaseObject { __ptr };
1034 let parent = hkReferencedObject {
1035 __ptr,
1036 parent,
1037 ..Default::default()
1038 };
1039 let parent = hkbBindable {
1040 __ptr,
1041 parent,
1042 m_variableBindingSet,
1043 ..Default::default()
1044 };
1045 let parent = hkbNode {
1046 __ptr,
1047 parent,
1048 m_userData,
1049 m_name,
1050 ..Default::default()
1051 };
1052 let parent = hkbModifier {
1053 __ptr,
1054 parent,
1055 m_enable,
1056 ..Default::default()
1057 };
1058 let __ptr = __A::class_ptr(&mut __map);
1059 _serde::__private::Ok(hkbTwistModifier {
1060 __ptr,
1061 parent,
1062 m_axisOfRotation,
1063 m_twistAngle,
1064 m_startBoneIndex,
1065 m_endBoneIndex,
1066 m_setAngleMethod,
1067 m_rotationAxisCoordinates,
1068 m_isAdditive,
1069 ..Default::default()
1070 })
1071 }
1072 }
1073 const FIELDS: &[&str] = &[
1074 "axisOfRotation",
1075 "twistAngle",
1076 "startBoneIndex",
1077 "endBoneIndex",
1078 "setAngleMethod",
1079 "rotationAxisCoordinates",
1080 "isAdditive",
1081 "boneChainIndices",
1082 "parentBoneIndices",
1083 ];
1084 _serde::Deserializer::deserialize_struct(
1085 deserializer,
1086 "hkbTwistModifier",
1087 FIELDS,
1088 __hkbTwistModifierVisitor {
1089 marker: _serde::__private::PhantomData::<hkbTwistModifier>,
1090 lifetime: _serde::__private::PhantomData,
1091 },
1092 )
1093 }
1094 }
1095};
1096#[allow(non_upper_case_globals, non_snake_case)]
1099#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1100#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1101#[derive(
1102 Debug,
1103 Clone,
1104 Default,
1105 PartialEq,
1106 Eq,
1107 PartialOrd,
1108 Ord,
1109 num_derive::ToPrimitive,
1110 num_derive::FromPrimitive,
1111)]
1112pub enum SetAngleMethod {
1113 #[default]
1114 LINEAR = 0isize,
1115 RAMPED = 1isize,
1116}
1117#[allow(non_upper_case_globals, non_snake_case)]
1120#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
1121#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
1122#[derive(
1123 Debug,
1124 Clone,
1125 Default,
1126 PartialEq,
1127 Eq,
1128 PartialOrd,
1129 Ord,
1130 num_derive::ToPrimitive,
1131 num_derive::FromPrimitive,
1132)]
1133pub enum RotationAxisCoordinates {
1134 #[default]
1135 ROTATION_AXIS_IN_MODEL_COORDINATES = 0isize,
1136 ROTATION_AXIS_IN_LOCAL_COORDINATES = 1isize,
1137}
1138const _: () = {
1139 use havok_serde as __serde;
1140 impl __serde::Serialize for SetAngleMethod {
1141 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1142 where
1143 S: __serde::ser::Serializer,
1144 {
1145 let mut __serializer = __serializer.serialize_enum_flags()?;
1146 match self {
1147 Self::LINEAR => __serializer.serialize_field("LINEAR", &0u64),
1148 Self::RAMPED => __serializer.serialize_field("RAMPED", &1u64),
1149 }?;
1150 use num_traits::ToPrimitive as _;
1151 let num = self
1152 .to_i8()
1153 .ok_or(S::Error::custom("Failed enum SetAngleMethod to_i8"))?;
1154 __serializer.serialize_bits(&num)?;
1155 __serializer.end()
1156 }
1157 }
1158};
1159const _: () = {
1160 use havok_serde as __serde;
1161 impl __serde::Serialize for RotationAxisCoordinates {
1162 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
1163 where
1164 S: __serde::ser::Serializer,
1165 {
1166 let mut __serializer = __serializer.serialize_enum_flags()?;
1167 match self {
1168 Self::ROTATION_AXIS_IN_MODEL_COORDINATES => {
1169 __serializer
1170 .serialize_field("ROTATION_AXIS_IN_MODEL_COORDINATES", &0u64)
1171 }
1172 Self::ROTATION_AXIS_IN_LOCAL_COORDINATES => {
1173 __serializer
1174 .serialize_field("ROTATION_AXIS_IN_LOCAL_COORDINATES", &1u64)
1175 }
1176 }?;
1177 use num_traits::ToPrimitive as _;
1178 let num = self
1179 .to_i8()
1180 .ok_or(S::Error::custom("Failed enum RotationAxisCoordinates to_i8"))?;
1181 __serializer.serialize_bits(&num)?;
1182 __serializer.end()
1183 }
1184 }
1185};
1186#[doc(hidden)]
1187#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1188const _: () = {
1189 #[allow(unused_extern_crates, clippy::useless_attribute)]
1190 extern crate havok_serde as _serde;
1191 #[automatically_derived]
1192 impl<'de> _serde::Deserialize<'de> for SetAngleMethod {
1193 fn deserialize<__D>(
1194 __deserializer: __D,
1195 ) -> _serde::__private::Result<Self, __D::Error>
1196 where
1197 __D: _serde::Deserializer<'de>,
1198 {
1199 #[allow(non_camel_case_types)]
1200 #[doc(hidden)]
1201 enum __Field {
1202 __field0,
1203 __field1,
1204 }
1205 #[doc(hidden)]
1206 struct __FieldVisitor;
1207 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1208 type Value = __Field;
1209 fn expecting(
1210 &self,
1211 __formatter: &mut _serde::__private::Formatter,
1212 ) -> _serde::__private::fmt::Result {
1213 _serde::__private::Formatter::write_str(
1214 __formatter,
1215 "variant identifier",
1216 )
1217 }
1218 fn visit_int8<__E>(
1219 self,
1220 __value: i8,
1221 ) -> _serde::__private::Result<Self::Value, __E>
1222 where
1223 __E: _serde::de::Error,
1224 {
1225 match __value {
1226 0i8 => _serde::__private::Ok(__Field::__field0),
1227 1i8 => _serde::__private::Ok(__Field::__field1),
1228 _ => {
1229 _serde::__private::Err(
1230 _serde::de::Error::invalid_value(
1231 _serde::de::Unexpected::Int8(__value),
1232 &"value(i8) of variant is one of 0, 1",
1233 ),
1234 )
1235 }
1236 }
1237 }
1238 fn visit_stringptr<__E>(
1239 self,
1240 __value: StringPtr<'de>,
1241 ) -> _serde::__private::Result<Self::Value, __E>
1242 where
1243 __E: _serde::de::Error,
1244 {
1245 if let Some(__value) = __value.into_inner() {
1246 match __value.as_ref() {
1247 v if v == "0" || v.eq_ignore_ascii_case("LINEAR") => {
1248 _serde::__private::Ok(__Field::__field0)
1249 }
1250 v if v == "1" || v.eq_ignore_ascii_case("RAMPED") => {
1251 _serde::__private::Ok(__Field::__field1)
1252 }
1253 _ => {
1254 _serde::__private::Err(
1255 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1256 )
1257 }
1258 }
1259 } else {
1260 _serde::__private::Err(
1261 _serde::de::Error::unknown_variant("None", VARIANTS),
1262 )
1263 }
1264 }
1265 }
1266 impl<'de> _serde::Deserialize<'de> for __Field {
1267 #[inline]
1268 fn deserialize<__D>(
1269 __deserializer: __D,
1270 ) -> _serde::__private::Result<Self, __D::Error>
1271 where
1272 __D: _serde::Deserializer<'de>,
1273 {
1274 _serde::Deserializer::deserialize_identifier(
1275 __deserializer,
1276 _serde::de::ReadEnumSize::Int8,
1277 __FieldVisitor,
1278 )
1279 }
1280 }
1281 #[doc(hidden)]
1282 struct __Visitor<'de> {
1283 marker: _serde::__private::PhantomData<SetAngleMethod>,
1284 lifetime: _serde::__private::PhantomData<&'de ()>,
1285 }
1286 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1287 type Value = SetAngleMethod;
1288 fn expecting(
1289 &self,
1290 __formatter: &mut _serde::__private::Formatter,
1291 ) -> _serde::__private::fmt::Result {
1292 _serde::__private::Formatter::write_str(
1293 __formatter,
1294 "enum SetAngleMethod",
1295 )
1296 }
1297 fn visit_enum<__A>(
1298 self,
1299 __data: __A,
1300 ) -> _serde::__private::Result<Self::Value, __A::Error>
1301 where
1302 __A: _serde::de::EnumAccess<'de>,
1303 {
1304 match _serde::de::EnumAccess::variant(__data)? {
1305 (__Field::__field0, __variant) => {
1306 _serde::de::VariantAccess::unit_variant(__variant)?;
1307 _serde::__private::Ok(SetAngleMethod::LINEAR)
1308 }
1309 (__Field::__field1, __variant) => {
1310 _serde::de::VariantAccess::unit_variant(__variant)?;
1311 _serde::__private::Ok(SetAngleMethod::RAMPED)
1312 }
1313 }
1314 }
1315 }
1316 #[doc(hidden)]
1317 const VARIANTS: &'static [&'static str] = &["LINEAR", "RAMPED"];
1318 _serde::Deserializer::deserialize_enum(
1319 __deserializer,
1320 "SetAngleMethod",
1321 VARIANTS,
1322 __Visitor {
1323 marker: _serde::__private::PhantomData::<SetAngleMethod>,
1324 lifetime: _serde::__private::PhantomData,
1325 },
1326 )
1327 }
1328 }
1329};
1330#[doc(hidden)]
1331#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
1332const _: () = {
1333 #[allow(unused_extern_crates, clippy::useless_attribute)]
1334 extern crate havok_serde as _serde;
1335 #[automatically_derived]
1336 impl<'de> _serde::Deserialize<'de> for RotationAxisCoordinates {
1337 fn deserialize<__D>(
1338 __deserializer: __D,
1339 ) -> _serde::__private::Result<Self, __D::Error>
1340 where
1341 __D: _serde::Deserializer<'de>,
1342 {
1343 #[allow(non_camel_case_types)]
1344 #[doc(hidden)]
1345 enum __Field {
1346 __field0,
1347 __field1,
1348 }
1349 #[doc(hidden)]
1350 struct __FieldVisitor;
1351 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1352 type Value = __Field;
1353 fn expecting(
1354 &self,
1355 __formatter: &mut _serde::__private::Formatter,
1356 ) -> _serde::__private::fmt::Result {
1357 _serde::__private::Formatter::write_str(
1358 __formatter,
1359 "variant identifier",
1360 )
1361 }
1362 fn visit_int8<__E>(
1363 self,
1364 __value: i8,
1365 ) -> _serde::__private::Result<Self::Value, __E>
1366 where
1367 __E: _serde::de::Error,
1368 {
1369 match __value {
1370 0i8 => _serde::__private::Ok(__Field::__field0),
1371 1i8 => _serde::__private::Ok(__Field::__field1),
1372 _ => {
1373 _serde::__private::Err(
1374 _serde::de::Error::invalid_value(
1375 _serde::de::Unexpected::Int8(__value),
1376 &"value(i8) of variant is one of 0, 1",
1377 ),
1378 )
1379 }
1380 }
1381 }
1382 fn visit_stringptr<__E>(
1383 self,
1384 __value: StringPtr<'de>,
1385 ) -> _serde::__private::Result<Self::Value, __E>
1386 where
1387 __E: _serde::de::Error,
1388 {
1389 if let Some(__value) = __value.into_inner() {
1390 match __value.as_ref() {
1391 v if v == "0"
1392 || v
1393 .eq_ignore_ascii_case(
1394 "ROTATION_AXIS_IN_MODEL_COORDINATES",
1395 ) => _serde::__private::Ok(__Field::__field0),
1396 v if v == "1"
1397 || v
1398 .eq_ignore_ascii_case(
1399 "ROTATION_AXIS_IN_LOCAL_COORDINATES",
1400 ) => _serde::__private::Ok(__Field::__field1),
1401 _ => {
1402 _serde::__private::Err(
1403 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1404 )
1405 }
1406 }
1407 } else {
1408 _serde::__private::Err(
1409 _serde::de::Error::unknown_variant("None", VARIANTS),
1410 )
1411 }
1412 }
1413 }
1414 impl<'de> _serde::Deserialize<'de> for __Field {
1415 #[inline]
1416 fn deserialize<__D>(
1417 __deserializer: __D,
1418 ) -> _serde::__private::Result<Self, __D::Error>
1419 where
1420 __D: _serde::Deserializer<'de>,
1421 {
1422 _serde::Deserializer::deserialize_identifier(
1423 __deserializer,
1424 _serde::de::ReadEnumSize::Int8,
1425 __FieldVisitor,
1426 )
1427 }
1428 }
1429 #[doc(hidden)]
1430 struct __Visitor<'de> {
1431 marker: _serde::__private::PhantomData<RotationAxisCoordinates>,
1432 lifetime: _serde::__private::PhantomData<&'de ()>,
1433 }
1434 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1435 type Value = RotationAxisCoordinates;
1436 fn expecting(
1437 &self,
1438 __formatter: &mut _serde::__private::Formatter,
1439 ) -> _serde::__private::fmt::Result {
1440 _serde::__private::Formatter::write_str(
1441 __formatter,
1442 "enum RotationAxisCoordinates",
1443 )
1444 }
1445 fn visit_enum<__A>(
1446 self,
1447 __data: __A,
1448 ) -> _serde::__private::Result<Self::Value, __A::Error>
1449 where
1450 __A: _serde::de::EnumAccess<'de>,
1451 {
1452 match _serde::de::EnumAccess::variant(__data)? {
1453 (__Field::__field0, __variant) => {
1454 _serde::de::VariantAccess::unit_variant(__variant)?;
1455 _serde::__private::Ok(
1456 RotationAxisCoordinates::ROTATION_AXIS_IN_MODEL_COORDINATES,
1457 )
1458 }
1459 (__Field::__field1, __variant) => {
1460 _serde::de::VariantAccess::unit_variant(__variant)?;
1461 _serde::__private::Ok(
1462 RotationAxisCoordinates::ROTATION_AXIS_IN_LOCAL_COORDINATES,
1463 )
1464 }
1465 }
1466 }
1467 }
1468 #[doc(hidden)]
1469 const VARIANTS: &'static [&'static str] = &[
1470 "ROTATION_AXIS_IN_MODEL_COORDINATES",
1471 "ROTATION_AXIS_IN_LOCAL_COORDINATES",
1472 ];
1473 _serde::Deserializer::deserialize_enum(
1474 __deserializer,
1475 "RotationAxisCoordinates",
1476 VARIANTS,
1477 __Visitor {
1478 marker: _serde::__private::PhantomData::<RotationAxisCoordinates>,
1479 lifetime: _serde::__private::PhantomData,
1480 },
1481 )
1482 }
1483 }
1484};