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