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