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 hkpSpringAction<'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: hkpBinaryAction<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "lastForce"))]
36 #[cfg_attr(feature = "serde", serde(rename = "lastForce"))]
37 pub m_lastForce: Vector4,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "positionAinA"))]
43 #[cfg_attr(feature = "serde", serde(rename = "positionAinA"))]
44 pub m_positionAinA: Vector4,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "positionBinB"))]
50 #[cfg_attr(feature = "serde", serde(rename = "positionBinB"))]
51 pub m_positionBinB: Vector4,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "restLength"))]
57 #[cfg_attr(feature = "serde", serde(rename = "restLength"))]
58 pub m_restLength: f32,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "strength"))]
64 #[cfg_attr(feature = "serde", serde(rename = "strength"))]
65 pub m_strength: f32,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "damping"))]
71 #[cfg_attr(feature = "serde", serde(rename = "damping"))]
72 pub m_damping: f32,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "onCompression"))]
78 #[cfg_attr(feature = "serde", serde(rename = "onCompression"))]
79 pub m_onCompression: bool,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "onExtension"))]
85 #[cfg_attr(feature = "serde", serde(rename = "onExtension"))]
86 pub m_onExtension: bool,
87}
88const _: () = {
89 use havok_serde as _serde;
90 impl<'a> _serde::HavokClass for hkpSpringAction<'a> {
91 #[inline]
92 fn name(&self) -> &'static str {
93 "hkpSpringAction"
94 }
95 #[inline]
96 fn signature(&self) -> _serde::__private::Signature {
97 _serde::__private::Signature::new(0x88fc09fa)
98 }
99 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
100 fn deps_indexes(&self) -> Vec<usize> {
101 let mut v = Vec::new();
102 v.push(self.parent.parent.m_world.get());
103 v.push(self.parent.parent.m_island.get());
104 v.push(self.parent.m_entityA.get());
105 v.push(self.parent.m_entityB.get());
106 v
107 }
108 }
109 impl<'a> _serde::Serialize for hkpSpringAction<'a> {
110 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
111 where
112 S: _serde::ser::Serializer,
113 {
114 let class_meta = self
115 .__ptr
116 .map(|name| (name, _serde::__private::Signature::new(0x88fc09fa)));
117 let mut serializer = __serializer
118 .serialize_struct("hkpSpringAction", class_meta, (96u64, 128u64))?;
119 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
120 serializer
121 .skip_field(
122 "memSizeAndFlags",
123 &self.parent.parent.parent.m_memSizeAndFlags,
124 )?;
125 serializer
126 .skip_field(
127 "referenceCount",
128 &self.parent.parent.parent.m_referenceCount,
129 )?;
130 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
131 serializer.skip_field("world", &self.parent.parent.m_world)?;
132 serializer.skip_field("island", &self.parent.parent.m_island)?;
133 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
134 serializer.serialize_field("name", &self.parent.parent.m_name)?;
135 serializer.serialize_field("entityA", &self.parent.m_entityA)?;
136 serializer.serialize_field("entityB", &self.parent.m_entityB)?;
137 serializer.serialize_field("lastForce", &self.m_lastForce)?;
138 serializer.serialize_field("positionAinA", &self.m_positionAinA)?;
139 serializer.serialize_field("positionBinB", &self.m_positionBinB)?;
140 serializer.serialize_field("restLength", &self.m_restLength)?;
141 serializer.serialize_field("strength", &self.m_strength)?;
142 serializer.serialize_field("damping", &self.m_damping)?;
143 serializer.serialize_field("onCompression", &self.m_onCompression)?;
144 serializer.serialize_field("onExtension", &self.m_onExtension)?;
145 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
146 serializer.end()
147 }
148 }
149};
150#[doc(hidden)]
151#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
152const _: () = {
153 use havok_serde as _serde;
154 #[automatically_derived]
155 impl<'de> _serde::Deserialize<'de> for hkpSpringAction<'de> {
156 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
157 where
158 __D: _serde::Deserializer<'de>,
159 {
160 #[allow(non_camel_case_types)]
161 enum __Field {
162 m_userData,
163 m_name,
164 m_entityA,
165 m_entityB,
166 m_lastForce,
167 m_positionAinA,
168 m_positionBinB,
169 m_restLength,
170 m_strength,
171 m_damping,
172 m_onCompression,
173 m_onExtension,
174 __ignore,
175 }
176 struct __FieldVisitor;
177 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
178 type Value = __Field;
179 fn expecting(
180 &self,
181 __formatter: &mut core::fmt::Formatter,
182 ) -> core::fmt::Result {
183 core::fmt::Formatter::write_str(__formatter, "field identifier")
184 }
185 #[allow(clippy::match_single_binding)]
187 #[allow(clippy::reversed_empty_ranges)]
188 #[allow(clippy::single_match)]
189 fn visit_key<__E>(
190 self,
191 __value: &str,
192 ) -> core::result::Result<Self::Value, __E>
193 where
194 __E: _serde::de::Error,
195 {
196 match __value {
197 "userData" => Ok(__Field::m_userData),
198 "name" => Ok(__Field::m_name),
199 "entityA" => Ok(__Field::m_entityA),
200 "entityB" => Ok(__Field::m_entityB),
201 "lastForce" => Ok(__Field::m_lastForce),
202 "positionAinA" => Ok(__Field::m_positionAinA),
203 "positionBinB" => Ok(__Field::m_positionBinB),
204 "restLength" => Ok(__Field::m_restLength),
205 "strength" => Ok(__Field::m_strength),
206 "damping" => Ok(__Field::m_damping),
207 "onCompression" => Ok(__Field::m_onCompression),
208 "onExtension" => Ok(__Field::m_onExtension),
209 _ => Ok(__Field::__ignore),
210 }
211 }
212 }
213 impl<'de> _serde::Deserialize<'de> for __Field {
214 #[inline]
215 fn deserialize<__D>(
216 __deserializer: __D,
217 ) -> core::result::Result<Self, __D::Error>
218 where
219 __D: _serde::Deserializer<'de>,
220 {
221 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
222 }
223 }
224 struct __hkpSpringActionVisitor<'de> {
225 marker: _serde::__private::PhantomData<hkpSpringAction<'de>>,
226 lifetime: _serde::__private::PhantomData<&'de ()>,
227 }
228 #[allow(clippy::match_single_binding)]
229 #[allow(clippy::reversed_empty_ranges)]
230 #[allow(clippy::single_match)]
231 impl<'de> _serde::de::Visitor<'de> for __hkpSpringActionVisitor<'de> {
232 type Value = hkpSpringAction<'de>;
233 fn expecting(
234 &self,
235 __formatter: &mut core::fmt::Formatter,
236 ) -> core::fmt::Result {
237 core::fmt::Formatter::write_str(
238 __formatter,
239 "struct hkpSpringAction",
240 )
241 }
242 fn visit_struct_for_bytes<__A>(
243 self,
244 mut __map: __A,
245 ) -> _serde::__private::Result<Self::Value, __A::Error>
246 where
247 __A: _serde::de::MapAccess<'de>,
248 {
249 let __ptr = __A::class_ptr(&mut __map);
250 let parent = __A::parent_value(&mut __map)?;
251 let mut m_lastForce: _serde::__private::Option<Vector4> = _serde::__private::None;
252 let mut m_positionAinA: _serde::__private::Option<Vector4> = _serde::__private::None;
253 let mut m_positionBinB: _serde::__private::Option<Vector4> = _serde::__private::None;
254 let mut m_restLength: _serde::__private::Option<f32> = _serde::__private::None;
255 let mut m_strength: _serde::__private::Option<f32> = _serde::__private::None;
256 let mut m_damping: _serde::__private::Option<f32> = _serde::__private::None;
257 let mut m_onCompression: _serde::__private::Option<bool> = _serde::__private::None;
258 let mut m_onExtension: _serde::__private::Option<bool> = _serde::__private::None;
259 for i in 0..8usize {
260 match i {
261 0usize => {
262 if _serde::__private::Option::is_some(&m_lastForce) {
263 return _serde::__private::Err(
264 <__A::Error as _serde::de::Error>::duplicate_field(
265 "lastForce",
266 ),
267 );
268 }
269 m_lastForce = _serde::__private::Some(
270 match __A::next_value::<Vector4>(&mut __map) {
271 _serde::__private::Ok(__val) => __val,
272 _serde::__private::Err(__err) => {
273 return _serde::__private::Err(__err);
274 }
275 },
276 );
277 }
278 1usize => {
279 if _serde::__private::Option::is_some(&m_positionAinA) {
280 return _serde::__private::Err(
281 <__A::Error as _serde::de::Error>::duplicate_field(
282 "positionAinA",
283 ),
284 );
285 }
286 m_positionAinA = _serde::__private::Some(
287 match __A::next_value::<Vector4>(&mut __map) {
288 _serde::__private::Ok(__val) => __val,
289 _serde::__private::Err(__err) => {
290 return _serde::__private::Err(__err);
291 }
292 },
293 );
294 }
295 2usize => {
296 if _serde::__private::Option::is_some(&m_positionBinB) {
297 return _serde::__private::Err(
298 <__A::Error as _serde::de::Error>::duplicate_field(
299 "positionBinB",
300 ),
301 );
302 }
303 m_positionBinB = _serde::__private::Some(
304 match __A::next_value::<Vector4>(&mut __map) {
305 _serde::__private::Ok(__val) => __val,
306 _serde::__private::Err(__err) => {
307 return _serde::__private::Err(__err);
308 }
309 },
310 );
311 }
312 3usize => {
313 if _serde::__private::Option::is_some(&m_restLength) {
314 return _serde::__private::Err(
315 <__A::Error as _serde::de::Error>::duplicate_field(
316 "restLength",
317 ),
318 );
319 }
320 m_restLength = _serde::__private::Some(
321 match __A::next_value::<f32>(&mut __map) {
322 _serde::__private::Ok(__val) => __val,
323 _serde::__private::Err(__err) => {
324 return _serde::__private::Err(__err);
325 }
326 },
327 );
328 }
329 4usize => {
330 if _serde::__private::Option::is_some(&m_strength) {
331 return _serde::__private::Err(
332 <__A::Error as _serde::de::Error>::duplicate_field(
333 "strength",
334 ),
335 );
336 }
337 m_strength = _serde::__private::Some(
338 match __A::next_value::<f32>(&mut __map) {
339 _serde::__private::Ok(__val) => __val,
340 _serde::__private::Err(__err) => {
341 return _serde::__private::Err(__err);
342 }
343 },
344 );
345 }
346 5usize => {
347 if _serde::__private::Option::is_some(&m_damping) {
348 return _serde::__private::Err(
349 <__A::Error as _serde::de::Error>::duplicate_field(
350 "damping",
351 ),
352 );
353 }
354 m_damping = _serde::__private::Some(
355 match __A::next_value::<f32>(&mut __map) {
356 _serde::__private::Ok(__val) => __val,
357 _serde::__private::Err(__err) => {
358 return _serde::__private::Err(__err);
359 }
360 },
361 );
362 }
363 6usize => {
364 if _serde::__private::Option::is_some(&m_onCompression) {
365 return _serde::__private::Err(
366 <__A::Error as _serde::de::Error>::duplicate_field(
367 "onCompression",
368 ),
369 );
370 }
371 m_onCompression = _serde::__private::Some(
372 match __A::next_value::<bool>(&mut __map) {
373 _serde::__private::Ok(__val) => __val,
374 _serde::__private::Err(__err) => {
375 return _serde::__private::Err(__err);
376 }
377 },
378 );
379 }
380 7usize => {
381 if _serde::__private::Option::is_some(&m_onExtension) {
382 return _serde::__private::Err(
383 <__A::Error as _serde::de::Error>::duplicate_field(
384 "onExtension",
385 ),
386 );
387 }
388 m_onExtension = _serde::__private::Some(
389 match __A::next_value::<bool>(&mut __map) {
390 _serde::__private::Ok(__val) => __val,
391 _serde::__private::Err(__err) => {
392 return _serde::__private::Err(__err);
393 }
394 },
395 );
396 }
397 _ => {}
398 }
399 }
400 __A::pad(&mut __map, 2usize, 2usize)?;
401 let m_lastForce = match m_lastForce {
402 _serde::__private::Some(__field) => __field,
403 _serde::__private::None => {
404 return _serde::__private::Err(
405 <__A::Error as _serde::de::Error>::missing_field(
406 "lastForce",
407 ),
408 );
409 }
410 };
411 let m_positionAinA = match m_positionAinA {
412 _serde::__private::Some(__field) => __field,
413 _serde::__private::None => {
414 return _serde::__private::Err(
415 <__A::Error as _serde::de::Error>::missing_field(
416 "positionAinA",
417 ),
418 );
419 }
420 };
421 let m_positionBinB = match m_positionBinB {
422 _serde::__private::Some(__field) => __field,
423 _serde::__private::None => {
424 return _serde::__private::Err(
425 <__A::Error as _serde::de::Error>::missing_field(
426 "positionBinB",
427 ),
428 );
429 }
430 };
431 let m_restLength = match m_restLength {
432 _serde::__private::Some(__field) => __field,
433 _serde::__private::None => {
434 return _serde::__private::Err(
435 <__A::Error as _serde::de::Error>::missing_field(
436 "restLength",
437 ),
438 );
439 }
440 };
441 let m_strength = match m_strength {
442 _serde::__private::Some(__field) => __field,
443 _serde::__private::None => {
444 return _serde::__private::Err(
445 <__A::Error as _serde::de::Error>::missing_field("strength"),
446 );
447 }
448 };
449 let m_damping = match m_damping {
450 _serde::__private::Some(__field) => __field,
451 _serde::__private::None => {
452 return _serde::__private::Err(
453 <__A::Error as _serde::de::Error>::missing_field("damping"),
454 );
455 }
456 };
457 let m_onCompression = match m_onCompression {
458 _serde::__private::Some(__field) => __field,
459 _serde::__private::None => {
460 return _serde::__private::Err(
461 <__A::Error as _serde::de::Error>::missing_field(
462 "onCompression",
463 ),
464 );
465 }
466 };
467 let m_onExtension = match m_onExtension {
468 _serde::__private::Some(__field) => __field,
469 _serde::__private::None => {
470 return _serde::__private::Err(
471 <__A::Error as _serde::de::Error>::missing_field(
472 "onExtension",
473 ),
474 );
475 }
476 };
477 _serde::__private::Ok(hkpSpringAction {
478 __ptr,
479 parent,
480 m_lastForce,
481 m_positionAinA,
482 m_positionBinB,
483 m_restLength,
484 m_strength,
485 m_damping,
486 m_onCompression,
487 m_onExtension,
488 })
489 }
490 #[allow(clippy::manual_unwrap_or_default)]
491 fn visit_struct<__A>(
492 self,
493 mut __map: __A,
494 ) -> _serde::__private::Result<Self::Value, __A::Error>
495 where
496 __A: _serde::de::MapAccess<'de>,
497 {
498 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
499 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
500 let mut m_entityA: _serde::__private::Option<Pointer> = _serde::__private::None;
501 let mut m_entityB: _serde::__private::Option<Pointer> = _serde::__private::None;
502 let mut m_lastForce: _serde::__private::Option<Vector4> = _serde::__private::None;
503 let mut m_positionAinA: _serde::__private::Option<Vector4> = _serde::__private::None;
504 let mut m_positionBinB: _serde::__private::Option<Vector4> = _serde::__private::None;
505 let mut m_restLength: _serde::__private::Option<f32> = _serde::__private::None;
506 let mut m_strength: _serde::__private::Option<f32> = _serde::__private::None;
507 let mut m_damping: _serde::__private::Option<f32> = _serde::__private::None;
508 let mut m_onCompression: _serde::__private::Option<bool> = _serde::__private::None;
509 let mut m_onExtension: _serde::__private::Option<bool> = _serde::__private::None;
510 while let _serde::__private::Some(__key) = {
511 __A::next_key::<__Field>(&mut __map)?
512 } {
513 match __key {
514 __Field::m_userData => {
515 #[cfg(
516 any(feature = "strict", feature = "ignore_duplicates")
517 )]
518 if _serde::__private::Option::is_some(&m_userData) {
519 #[cfg(feature = "ignore_duplicates")]
520 {
521 __A::skip_value(&mut __map)?;
522 continue;
523 }
524 #[cfg(feature = "strict")]
525 return _serde::__private::Err(
526 <__A::Error as _serde::de::Error>::duplicate_field(
527 "userData",
528 ),
529 );
530 }
531 m_userData = _serde::__private::Some(
532 match __A::next_value::<Ulong>(&mut __map) {
533 _serde::__private::Ok(__val) => __val,
534 _serde::__private::Err(__err) => {
535 return _serde::__private::Err(__err);
536 }
537 },
538 );
539 }
540 __Field::m_name => {
541 #[cfg(
542 any(feature = "strict", feature = "ignore_duplicates")
543 )]
544 if _serde::__private::Option::is_some(&m_name) {
545 #[cfg(feature = "ignore_duplicates")]
546 {
547 __A::skip_value(&mut __map)?;
548 continue;
549 }
550 #[cfg(feature = "strict")]
551 return _serde::__private::Err(
552 <__A::Error as _serde::de::Error>::duplicate_field("name"),
553 );
554 }
555 m_name = _serde::__private::Some(
556 match __A::next_value::<StringPtr<'de>>(&mut __map) {
557 _serde::__private::Ok(__val) => __val,
558 _serde::__private::Err(__err) => {
559 return _serde::__private::Err(__err);
560 }
561 },
562 );
563 }
564 __Field::m_entityA => {
565 #[cfg(
566 any(feature = "strict", feature = "ignore_duplicates")
567 )]
568 if _serde::__private::Option::is_some(&m_entityA) {
569 #[cfg(feature = "ignore_duplicates")]
570 {
571 __A::skip_value(&mut __map)?;
572 continue;
573 }
574 #[cfg(feature = "strict")]
575 return _serde::__private::Err(
576 <__A::Error as _serde::de::Error>::duplicate_field(
577 "entityA",
578 ),
579 );
580 }
581 m_entityA = _serde::__private::Some(
582 match __A::next_value::<Pointer>(&mut __map) {
583 _serde::__private::Ok(__val) => __val,
584 _serde::__private::Err(__err) => {
585 return _serde::__private::Err(__err);
586 }
587 },
588 );
589 }
590 __Field::m_entityB => {
591 #[cfg(
592 any(feature = "strict", feature = "ignore_duplicates")
593 )]
594 if _serde::__private::Option::is_some(&m_entityB) {
595 #[cfg(feature = "ignore_duplicates")]
596 {
597 __A::skip_value(&mut __map)?;
598 continue;
599 }
600 #[cfg(feature = "strict")]
601 return _serde::__private::Err(
602 <__A::Error as _serde::de::Error>::duplicate_field(
603 "entityB",
604 ),
605 );
606 }
607 m_entityB = _serde::__private::Some(
608 match __A::next_value::<Pointer>(&mut __map) {
609 _serde::__private::Ok(__val) => __val,
610 _serde::__private::Err(__err) => {
611 return _serde::__private::Err(__err);
612 }
613 },
614 );
615 }
616 __Field::m_lastForce => {
617 #[cfg(
618 any(feature = "strict", feature = "ignore_duplicates")
619 )]
620 if _serde::__private::Option::is_some(&m_lastForce) {
621 #[cfg(feature = "ignore_duplicates")]
622 {
623 __A::skip_value(&mut __map)?;
624 continue;
625 }
626 #[cfg(feature = "strict")]
627 return _serde::__private::Err(
628 <__A::Error as _serde::de::Error>::duplicate_field(
629 "lastForce",
630 ),
631 );
632 }
633 m_lastForce = _serde::__private::Some(
634 match __A::next_value::<Vector4>(&mut __map) {
635 _serde::__private::Ok(__val) => __val,
636 _serde::__private::Err(__err) => {
637 return _serde::__private::Err(__err);
638 }
639 },
640 );
641 }
642 __Field::m_positionAinA => {
643 #[cfg(
644 any(feature = "strict", feature = "ignore_duplicates")
645 )]
646 if _serde::__private::Option::is_some(&m_positionAinA) {
647 #[cfg(feature = "ignore_duplicates")]
648 {
649 __A::skip_value(&mut __map)?;
650 continue;
651 }
652 #[cfg(feature = "strict")]
653 return _serde::__private::Err(
654 <__A::Error as _serde::de::Error>::duplicate_field(
655 "positionAinA",
656 ),
657 );
658 }
659 m_positionAinA = _serde::__private::Some(
660 match __A::next_value::<Vector4>(&mut __map) {
661 _serde::__private::Ok(__val) => __val,
662 _serde::__private::Err(__err) => {
663 return _serde::__private::Err(__err);
664 }
665 },
666 );
667 }
668 __Field::m_positionBinB => {
669 #[cfg(
670 any(feature = "strict", feature = "ignore_duplicates")
671 )]
672 if _serde::__private::Option::is_some(&m_positionBinB) {
673 #[cfg(feature = "ignore_duplicates")]
674 {
675 __A::skip_value(&mut __map)?;
676 continue;
677 }
678 #[cfg(feature = "strict")]
679 return _serde::__private::Err(
680 <__A::Error as _serde::de::Error>::duplicate_field(
681 "positionBinB",
682 ),
683 );
684 }
685 m_positionBinB = _serde::__private::Some(
686 match __A::next_value::<Vector4>(&mut __map) {
687 _serde::__private::Ok(__val) => __val,
688 _serde::__private::Err(__err) => {
689 return _serde::__private::Err(__err);
690 }
691 },
692 );
693 }
694 __Field::m_restLength => {
695 #[cfg(
696 any(feature = "strict", feature = "ignore_duplicates")
697 )]
698 if _serde::__private::Option::is_some(&m_restLength) {
699 #[cfg(feature = "ignore_duplicates")]
700 {
701 __A::skip_value(&mut __map)?;
702 continue;
703 }
704 #[cfg(feature = "strict")]
705 return _serde::__private::Err(
706 <__A::Error as _serde::de::Error>::duplicate_field(
707 "restLength",
708 ),
709 );
710 }
711 m_restLength = _serde::__private::Some(
712 match __A::next_value::<f32>(&mut __map) {
713 _serde::__private::Ok(__val) => __val,
714 _serde::__private::Err(__err) => {
715 return _serde::__private::Err(__err);
716 }
717 },
718 );
719 }
720 __Field::m_strength => {
721 #[cfg(
722 any(feature = "strict", feature = "ignore_duplicates")
723 )]
724 if _serde::__private::Option::is_some(&m_strength) {
725 #[cfg(feature = "ignore_duplicates")]
726 {
727 __A::skip_value(&mut __map)?;
728 continue;
729 }
730 #[cfg(feature = "strict")]
731 return _serde::__private::Err(
732 <__A::Error as _serde::de::Error>::duplicate_field(
733 "strength",
734 ),
735 );
736 }
737 m_strength = _serde::__private::Some(
738 match __A::next_value::<f32>(&mut __map) {
739 _serde::__private::Ok(__val) => __val,
740 _serde::__private::Err(__err) => {
741 return _serde::__private::Err(__err);
742 }
743 },
744 );
745 }
746 __Field::m_damping => {
747 #[cfg(
748 any(feature = "strict", feature = "ignore_duplicates")
749 )]
750 if _serde::__private::Option::is_some(&m_damping) {
751 #[cfg(feature = "ignore_duplicates")]
752 {
753 __A::skip_value(&mut __map)?;
754 continue;
755 }
756 #[cfg(feature = "strict")]
757 return _serde::__private::Err(
758 <__A::Error as _serde::de::Error>::duplicate_field(
759 "damping",
760 ),
761 );
762 }
763 m_damping = _serde::__private::Some(
764 match __A::next_value::<f32>(&mut __map) {
765 _serde::__private::Ok(__val) => __val,
766 _serde::__private::Err(__err) => {
767 return _serde::__private::Err(__err);
768 }
769 },
770 );
771 }
772 __Field::m_onCompression => {
773 #[cfg(
774 any(feature = "strict", feature = "ignore_duplicates")
775 )]
776 if _serde::__private::Option::is_some(&m_onCompression) {
777 #[cfg(feature = "ignore_duplicates")]
778 {
779 __A::skip_value(&mut __map)?;
780 continue;
781 }
782 #[cfg(feature = "strict")]
783 return _serde::__private::Err(
784 <__A::Error as _serde::de::Error>::duplicate_field(
785 "onCompression",
786 ),
787 );
788 }
789 m_onCompression = _serde::__private::Some(
790 match __A::next_value::<bool>(&mut __map) {
791 _serde::__private::Ok(__val) => __val,
792 _serde::__private::Err(__err) => {
793 return _serde::__private::Err(__err);
794 }
795 },
796 );
797 }
798 __Field::m_onExtension => {
799 #[cfg(
800 any(feature = "strict", feature = "ignore_duplicates")
801 )]
802 if _serde::__private::Option::is_some(&m_onExtension) {
803 #[cfg(feature = "ignore_duplicates")]
804 {
805 __A::skip_value(&mut __map)?;
806 continue;
807 }
808 #[cfg(feature = "strict")]
809 return _serde::__private::Err(
810 <__A::Error as _serde::de::Error>::duplicate_field(
811 "onExtension",
812 ),
813 );
814 }
815 m_onExtension = _serde::__private::Some(
816 match __A::next_value::<bool>(&mut __map) {
817 _serde::__private::Ok(__val) => __val,
818 _serde::__private::Err(__err) => {
819 return _serde::__private::Err(__err);
820 }
821 },
822 );
823 }
824 _ => __A::skip_value(&mut __map)?,
825 }
826 }
827 let m_userData = match m_userData {
828 _serde::__private::Some(__field) => __field,
829 _serde::__private::None => {
830 #[cfg(feature = "strict")]
831 return _serde::__private::Err(
832 <__A::Error as _serde::de::Error>::missing_field("userData"),
833 );
834 #[cfg(not(feature = "strict"))] Default::default()
835 }
836 };
837 let m_name = match m_name {
838 _serde::__private::Some(__field) => __field,
839 _serde::__private::None => {
840 #[cfg(feature = "strict")]
841 return _serde::__private::Err(
842 <__A::Error as _serde::de::Error>::missing_field("name"),
843 );
844 #[cfg(not(feature = "strict"))] Default::default()
845 }
846 };
847 let m_entityA = match m_entityA {
848 _serde::__private::Some(__field) => __field,
849 _serde::__private::None => {
850 #[cfg(feature = "strict")]
851 return _serde::__private::Err(
852 <__A::Error as _serde::de::Error>::missing_field("entityA"),
853 );
854 #[cfg(not(feature = "strict"))] Default::default()
855 }
856 };
857 let m_entityB = match m_entityB {
858 _serde::__private::Some(__field) => __field,
859 _serde::__private::None => {
860 #[cfg(feature = "strict")]
861 return _serde::__private::Err(
862 <__A::Error as _serde::de::Error>::missing_field("entityB"),
863 );
864 #[cfg(not(feature = "strict"))] Default::default()
865 }
866 };
867 let m_lastForce = match m_lastForce {
868 _serde::__private::Some(__field) => __field,
869 _serde::__private::None => {
870 #[cfg(feature = "strict")]
871 return _serde::__private::Err(
872 <__A::Error as _serde::de::Error>::missing_field(
873 "lastForce",
874 ),
875 );
876 #[cfg(not(feature = "strict"))] Default::default()
877 }
878 };
879 let m_positionAinA = match m_positionAinA {
880 _serde::__private::Some(__field) => __field,
881 _serde::__private::None => {
882 #[cfg(feature = "strict")]
883 return _serde::__private::Err(
884 <__A::Error as _serde::de::Error>::missing_field(
885 "positionAinA",
886 ),
887 );
888 #[cfg(not(feature = "strict"))] Default::default()
889 }
890 };
891 let m_positionBinB = match m_positionBinB {
892 _serde::__private::Some(__field) => __field,
893 _serde::__private::None => {
894 #[cfg(feature = "strict")]
895 return _serde::__private::Err(
896 <__A::Error as _serde::de::Error>::missing_field(
897 "positionBinB",
898 ),
899 );
900 #[cfg(not(feature = "strict"))] Default::default()
901 }
902 };
903 let m_restLength = match m_restLength {
904 _serde::__private::Some(__field) => __field,
905 _serde::__private::None => {
906 #[cfg(feature = "strict")]
907 return _serde::__private::Err(
908 <__A::Error as _serde::de::Error>::missing_field(
909 "restLength",
910 ),
911 );
912 #[cfg(not(feature = "strict"))] Default::default()
913 }
914 };
915 let m_strength = match m_strength {
916 _serde::__private::Some(__field) => __field,
917 _serde::__private::None => {
918 #[cfg(feature = "strict")]
919 return _serde::__private::Err(
920 <__A::Error as _serde::de::Error>::missing_field("strength"),
921 );
922 #[cfg(not(feature = "strict"))] Default::default()
923 }
924 };
925 let m_damping = match m_damping {
926 _serde::__private::Some(__field) => __field,
927 _serde::__private::None => {
928 #[cfg(feature = "strict")]
929 return _serde::__private::Err(
930 <__A::Error as _serde::de::Error>::missing_field("damping"),
931 );
932 #[cfg(not(feature = "strict"))] Default::default()
933 }
934 };
935 let m_onCompression = match m_onCompression {
936 _serde::__private::Some(__field) => __field,
937 _serde::__private::None => {
938 #[cfg(feature = "strict")]
939 return _serde::__private::Err(
940 <__A::Error as _serde::de::Error>::missing_field(
941 "onCompression",
942 ),
943 );
944 #[cfg(not(feature = "strict"))] Default::default()
945 }
946 };
947 let m_onExtension = match m_onExtension {
948 _serde::__private::Some(__field) => __field,
949 _serde::__private::None => {
950 #[cfg(feature = "strict")]
951 return _serde::__private::Err(
952 <__A::Error as _serde::de::Error>::missing_field(
953 "onExtension",
954 ),
955 );
956 #[cfg(not(feature = "strict"))] Default::default()
957 }
958 };
959 let __ptr = None;
960 let parent = hkBaseObject { __ptr };
961 let parent = hkReferencedObject {
962 __ptr,
963 parent,
964 ..Default::default()
965 };
966 let parent = hkpAction {
967 __ptr,
968 parent,
969 m_userData,
970 m_name,
971 ..Default::default()
972 };
973 let parent = hkpBinaryAction {
974 __ptr,
975 parent,
976 m_entityA,
977 m_entityB,
978 };
979 let __ptr = __A::class_ptr(&mut __map);
980 _serde::__private::Ok(hkpSpringAction {
981 __ptr,
982 parent,
983 m_lastForce,
984 m_positionAinA,
985 m_positionBinB,
986 m_restLength,
987 m_strength,
988 m_damping,
989 m_onCompression,
990 m_onExtension,
991 })
992 }
993 }
994 const FIELDS: &[&str] = &[
995 "lastForce",
996 "positionAinA",
997 "positionBinB",
998 "restLength",
999 "strength",
1000 "damping",
1001 "onCompression",
1002 "onExtension",
1003 ];
1004 _serde::Deserializer::deserialize_struct(
1005 deserializer,
1006 "hkpSpringAction",
1007 FIELDS,
1008 __hkpSpringActionVisitor {
1009 marker: _serde::__private::PhantomData::<hkpSpringAction>,
1010 lifetime: _serde::__private::PhantomData,
1011 },
1012 )
1013 }
1014 }
1015};