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