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