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 hkpBreakableConstraintData {
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: hkpConstraintData,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "atoms"))]
35 #[cfg_attr(feature = "serde", serde(rename = "atoms"))]
36 pub m_atoms: hkpBridgeAtoms,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "constraintData"))]
42 #[cfg_attr(feature = "serde", serde(rename = "constraintData"))]
43 pub m_constraintData: Pointer,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "childRuntimeSize"))]
49 #[cfg_attr(feature = "serde", serde(rename = "childRuntimeSize"))]
50 pub m_childRuntimeSize: u16,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "childNumSolverResults"))]
56 #[cfg_attr(feature = "serde", serde(rename = "childNumSolverResults"))]
57 pub m_childNumSolverResults: u16,
58 #[cfg_attr(feature = "json_schema", schemars(rename = "solverResultLimit"))]
63 #[cfg_attr(feature = "serde", serde(rename = "solverResultLimit"))]
64 pub m_solverResultLimit: f32,
65 #[cfg_attr(feature = "json_schema", schemars(rename = "removeWhenBroken"))]
70 #[cfg_attr(feature = "serde", serde(rename = "removeWhenBroken"))]
71 pub m_removeWhenBroken: bool,
72 #[cfg_attr(feature = "json_schema", schemars(rename = "revertBackVelocityOnBreak"))]
77 #[cfg_attr(feature = "serde", serde(rename = "revertBackVelocityOnBreak"))]
78 pub m_revertBackVelocityOnBreak: bool,
79}
80const _: () = {
81 use havok_serde as _serde;
82 impl _serde::HavokClass for hkpBreakableConstraintData {
83 #[inline]
84 fn name(&self) -> &'static str {
85 "hkpBreakableConstraintData"
86 }
87 #[inline]
88 fn signature(&self) -> _serde::__private::Signature {
89 _serde::__private::Signature::new(0x7d6310c8)
90 }
91 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
92 fn deps_indexes(&self) -> Vec<usize> {
93 let mut v = Vec::new();
94 v.extend(self.m_atoms.deps_indexes());
95 v.push(self.m_constraintData.get());
96 v
97 }
98 }
99 impl _serde::Serialize for hkpBreakableConstraintData {
100 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
101 where
102 S: _serde::ser::Serializer,
103 {
104 let class_meta = self
105 .__ptr
106 .map(|name| (name, _serde::__private::Signature::new(0x7d6310c8)));
107 let mut serializer = __serializer
108 .serialize_struct(
109 "hkpBreakableConstraintData",
110 class_meta,
111 (40u64, 72u64),
112 )?;
113 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
114 serializer
115 .skip_field("memSizeAndFlags", &self.parent.parent.m_memSizeAndFlags)?;
116 serializer
117 .skip_field("referenceCount", &self.parent.parent.m_referenceCount)?;
118 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
119 serializer.serialize_field("userData", &self.parent.m_userData)?;
120 serializer.serialize_field("atoms", &self.m_atoms)?;
121 serializer.serialize_field("constraintData", &self.m_constraintData)?;
122 serializer.serialize_field("childRuntimeSize", &self.m_childRuntimeSize)?;
123 serializer
124 .serialize_field(
125 "childNumSolverResults",
126 &self.m_childNumSolverResults,
127 )?;
128 serializer.serialize_field("solverResultLimit", &self.m_solverResultLimit)?;
129 serializer.serialize_field("removeWhenBroken", &self.m_removeWhenBroken)?;
130 serializer
131 .serialize_field(
132 "revertBackVelocityOnBreak",
133 &self.m_revertBackVelocityOnBreak,
134 )?;
135 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 6usize].as_slice())?;
136 serializer.end()
137 }
138 }
139};
140#[doc(hidden)]
141#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
142const _: () = {
143 use havok_serde as _serde;
144 #[automatically_derived]
145 impl<'de> _serde::Deserialize<'de> for hkpBreakableConstraintData {
146 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
147 where
148 __D: _serde::Deserializer<'de>,
149 {
150 #[allow(non_camel_case_types)]
151 enum __Field {
152 m_userData,
153 m_atoms,
154 m_constraintData,
155 m_childRuntimeSize,
156 m_childNumSolverResults,
157 m_solverResultLimit,
158 m_removeWhenBroken,
159 m_revertBackVelocityOnBreak,
160 __ignore,
161 }
162 struct __FieldVisitor;
163 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
164 type Value = __Field;
165 fn expecting(
166 &self,
167 __formatter: &mut core::fmt::Formatter,
168 ) -> core::fmt::Result {
169 core::fmt::Formatter::write_str(__formatter, "field identifier")
170 }
171 #[allow(clippy::match_single_binding)]
173 #[allow(clippy::reversed_empty_ranges)]
174 #[allow(clippy::single_match)]
175 fn visit_key<__E>(
176 self,
177 __value: &str,
178 ) -> core::result::Result<Self::Value, __E>
179 where
180 __E: _serde::de::Error,
181 {
182 match __value {
183 "userData" => Ok(__Field::m_userData),
184 "atoms" => Ok(__Field::m_atoms),
185 "constraintData" => Ok(__Field::m_constraintData),
186 "childRuntimeSize" => Ok(__Field::m_childRuntimeSize),
187 "childNumSolverResults" => Ok(__Field::m_childNumSolverResults),
188 "solverResultLimit" => Ok(__Field::m_solverResultLimit),
189 "removeWhenBroken" => Ok(__Field::m_removeWhenBroken),
190 "revertBackVelocityOnBreak" => {
191 Ok(__Field::m_revertBackVelocityOnBreak)
192 }
193 _ => Ok(__Field::__ignore),
194 }
195 }
196 }
197 impl<'de> _serde::Deserialize<'de> for __Field {
198 #[inline]
199 fn deserialize<__D>(
200 __deserializer: __D,
201 ) -> core::result::Result<Self, __D::Error>
202 where
203 __D: _serde::Deserializer<'de>,
204 {
205 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
206 }
207 }
208 struct __hkpBreakableConstraintDataVisitor<'de> {
209 marker: _serde::__private::PhantomData<hkpBreakableConstraintData>,
210 lifetime: _serde::__private::PhantomData<&'de ()>,
211 }
212 #[allow(clippy::match_single_binding)]
213 #[allow(clippy::reversed_empty_ranges)]
214 #[allow(clippy::single_match)]
215 impl<'de> _serde::de::Visitor<'de>
216 for __hkpBreakableConstraintDataVisitor<'de> {
217 type Value = hkpBreakableConstraintData;
218 fn expecting(
219 &self,
220 __formatter: &mut core::fmt::Formatter,
221 ) -> core::fmt::Result {
222 core::fmt::Formatter::write_str(
223 __formatter,
224 "struct hkpBreakableConstraintData",
225 )
226 }
227 fn visit_struct_for_bytes<__A>(
228 self,
229 mut __map: __A,
230 ) -> _serde::__private::Result<Self::Value, __A::Error>
231 where
232 __A: _serde::de::MapAccess<'de>,
233 {
234 let __ptr = __A::class_ptr(&mut __map);
235 let parent = __A::parent_value(&mut __map)?;
236 let mut m_atoms: _serde::__private::Option<hkpBridgeAtoms> = _serde::__private::None;
237 let mut m_constraintData: _serde::__private::Option<Pointer> = _serde::__private::None;
238 let mut m_childRuntimeSize: _serde::__private::Option<u16> = _serde::__private::None;
239 let mut m_childNumSolverResults: _serde::__private::Option<u16> = _serde::__private::None;
240 let mut m_solverResultLimit: _serde::__private::Option<f32> = _serde::__private::None;
241 let mut m_removeWhenBroken: _serde::__private::Option<bool> = _serde::__private::None;
242 let mut m_revertBackVelocityOnBreak: _serde::__private::Option<
243 bool,
244 > = _serde::__private::None;
245 for i in 0..7usize {
246 match i {
247 0usize => {
248 if _serde::__private::Option::is_some(&m_atoms) {
249 return _serde::__private::Err(
250 <__A::Error as _serde::de::Error>::duplicate_field("atoms"),
251 );
252 }
253 m_atoms = _serde::__private::Some(
254 match __A::next_value::<hkpBridgeAtoms>(&mut __map) {
255 _serde::__private::Ok(__val) => __val,
256 _serde::__private::Err(__err) => {
257 return _serde::__private::Err(__err);
258 }
259 },
260 );
261 }
262 1usize => {
263 if _serde::__private::Option::is_some(&m_constraintData) {
264 return _serde::__private::Err(
265 <__A::Error as _serde::de::Error>::duplicate_field(
266 "constraintData",
267 ),
268 );
269 }
270 m_constraintData = _serde::__private::Some(
271 match __A::next_value::<Pointer>(&mut __map) {
272 _serde::__private::Ok(__val) => __val,
273 _serde::__private::Err(__err) => {
274 return _serde::__private::Err(__err);
275 }
276 },
277 );
278 }
279 2usize => {
280 if _serde::__private::Option::is_some(&m_childRuntimeSize) {
281 return _serde::__private::Err(
282 <__A::Error as _serde::de::Error>::duplicate_field(
283 "childRuntimeSize",
284 ),
285 );
286 }
287 m_childRuntimeSize = _serde::__private::Some(
288 match __A::next_value::<u16>(&mut __map) {
289 _serde::__private::Ok(__val) => __val,
290 _serde::__private::Err(__err) => {
291 return _serde::__private::Err(__err);
292 }
293 },
294 );
295 }
296 3usize => {
297 if _serde::__private::Option::is_some(
298 &m_childNumSolverResults,
299 ) {
300 return _serde::__private::Err(
301 <__A::Error as _serde::de::Error>::duplicate_field(
302 "childNumSolverResults",
303 ),
304 );
305 }
306 m_childNumSolverResults = _serde::__private::Some(
307 match __A::next_value::<u16>(&mut __map) {
308 _serde::__private::Ok(__val) => __val,
309 _serde::__private::Err(__err) => {
310 return _serde::__private::Err(__err);
311 }
312 },
313 );
314 }
315 4usize => {
316 if _serde::__private::Option::is_some(
317 &m_solverResultLimit,
318 ) {
319 return _serde::__private::Err(
320 <__A::Error as _serde::de::Error>::duplicate_field(
321 "solverResultLimit",
322 ),
323 );
324 }
325 m_solverResultLimit = _serde::__private::Some(
326 match __A::next_value::<f32>(&mut __map) {
327 _serde::__private::Ok(__val) => __val,
328 _serde::__private::Err(__err) => {
329 return _serde::__private::Err(__err);
330 }
331 },
332 );
333 }
334 5usize => {
335 if _serde::__private::Option::is_some(&m_removeWhenBroken) {
336 return _serde::__private::Err(
337 <__A::Error as _serde::de::Error>::duplicate_field(
338 "removeWhenBroken",
339 ),
340 );
341 }
342 m_removeWhenBroken = _serde::__private::Some(
343 match __A::next_value::<bool>(&mut __map) {
344 _serde::__private::Ok(__val) => __val,
345 _serde::__private::Err(__err) => {
346 return _serde::__private::Err(__err);
347 }
348 },
349 );
350 }
351 6usize => {
352 if _serde::__private::Option::is_some(
353 &m_revertBackVelocityOnBreak,
354 ) {
355 return _serde::__private::Err(
356 <__A::Error as _serde::de::Error>::duplicate_field(
357 "revertBackVelocityOnBreak",
358 ),
359 );
360 }
361 m_revertBackVelocityOnBreak = _serde::__private::Some(
362 match __A::next_value::<bool>(&mut __map) {
363 _serde::__private::Ok(__val) => __val,
364 _serde::__private::Err(__err) => {
365 return _serde::__private::Err(__err);
366 }
367 },
368 );
369 }
370 _ => {}
371 }
372 }
373 __A::pad(&mut __map, 2usize, 6usize)?;
374 let m_atoms = match m_atoms {
375 _serde::__private::Some(__field) => __field,
376 _serde::__private::None => {
377 return _serde::__private::Err(
378 <__A::Error as _serde::de::Error>::missing_field("atoms"),
379 );
380 }
381 };
382 let m_constraintData = match m_constraintData {
383 _serde::__private::Some(__field) => __field,
384 _serde::__private::None => {
385 return _serde::__private::Err(
386 <__A::Error as _serde::de::Error>::missing_field(
387 "constraintData",
388 ),
389 );
390 }
391 };
392 let m_childRuntimeSize = match m_childRuntimeSize {
393 _serde::__private::Some(__field) => __field,
394 _serde::__private::None => {
395 return _serde::__private::Err(
396 <__A::Error as _serde::de::Error>::missing_field(
397 "childRuntimeSize",
398 ),
399 );
400 }
401 };
402 let m_childNumSolverResults = match m_childNumSolverResults {
403 _serde::__private::Some(__field) => __field,
404 _serde::__private::None => {
405 return _serde::__private::Err(
406 <__A::Error as _serde::de::Error>::missing_field(
407 "childNumSolverResults",
408 ),
409 );
410 }
411 };
412 let m_solverResultLimit = match m_solverResultLimit {
413 _serde::__private::Some(__field) => __field,
414 _serde::__private::None => {
415 return _serde::__private::Err(
416 <__A::Error as _serde::de::Error>::missing_field(
417 "solverResultLimit",
418 ),
419 );
420 }
421 };
422 let m_removeWhenBroken = match m_removeWhenBroken {
423 _serde::__private::Some(__field) => __field,
424 _serde::__private::None => {
425 return _serde::__private::Err(
426 <__A::Error as _serde::de::Error>::missing_field(
427 "removeWhenBroken",
428 ),
429 );
430 }
431 };
432 let m_revertBackVelocityOnBreak = match m_revertBackVelocityOnBreak {
433 _serde::__private::Some(__field) => __field,
434 _serde::__private::None => {
435 return _serde::__private::Err(
436 <__A::Error as _serde::de::Error>::missing_field(
437 "revertBackVelocityOnBreak",
438 ),
439 );
440 }
441 };
442 _serde::__private::Ok(hkpBreakableConstraintData {
443 __ptr,
444 parent,
445 m_atoms,
446 m_constraintData,
447 m_childRuntimeSize,
448 m_childNumSolverResults,
449 m_solverResultLimit,
450 m_removeWhenBroken,
451 m_revertBackVelocityOnBreak,
452 })
453 }
454 #[allow(clippy::manual_unwrap_or_default)]
455 fn visit_struct<__A>(
456 self,
457 mut __map: __A,
458 ) -> _serde::__private::Result<Self::Value, __A::Error>
459 where
460 __A: _serde::de::MapAccess<'de>,
461 {
462 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
463 let mut m_atoms: _serde::__private::Option<hkpBridgeAtoms> = _serde::__private::None;
464 let mut m_constraintData: _serde::__private::Option<Pointer> = _serde::__private::None;
465 let mut m_childRuntimeSize: _serde::__private::Option<u16> = _serde::__private::None;
466 let mut m_childNumSolverResults: _serde::__private::Option<u16> = _serde::__private::None;
467 let mut m_solverResultLimit: _serde::__private::Option<f32> = _serde::__private::None;
468 let mut m_removeWhenBroken: _serde::__private::Option<bool> = _serde::__private::None;
469 let mut m_revertBackVelocityOnBreak: _serde::__private::Option<
470 bool,
471 > = _serde::__private::None;
472 while let _serde::__private::Some(__key) = {
473 __A::next_key::<__Field>(&mut __map)?
474 } {
475 match __key {
476 __Field::m_userData => {
477 #[cfg(
478 any(feature = "strict", feature = "ignore_duplicates")
479 )]
480 if _serde::__private::Option::is_some(&m_userData) {
481 #[cfg(feature = "ignore_duplicates")]
482 {
483 __A::skip_value(&mut __map)?;
484 continue;
485 }
486 #[cfg(feature = "strict")]
487 return _serde::__private::Err(
488 <__A::Error as _serde::de::Error>::duplicate_field(
489 "userData",
490 ),
491 );
492 }
493 m_userData = _serde::__private::Some(
494 match __A::next_value::<Ulong>(&mut __map) {
495 _serde::__private::Ok(__val) => __val,
496 _serde::__private::Err(__err) => {
497 return _serde::__private::Err(__err);
498 }
499 },
500 );
501 }
502 __Field::m_atoms => {
503 #[cfg(
504 any(feature = "strict", feature = "ignore_duplicates")
505 )]
506 if _serde::__private::Option::is_some(&m_atoms) {
507 #[cfg(feature = "ignore_duplicates")]
508 {
509 __A::skip_value(&mut __map)?;
510 continue;
511 }
512 #[cfg(feature = "strict")]
513 return _serde::__private::Err(
514 <__A::Error as _serde::de::Error>::duplicate_field("atoms"),
515 );
516 }
517 m_atoms = _serde::__private::Some(
518 match __A::next_value::<hkpBridgeAtoms>(&mut __map) {
519 _serde::__private::Ok(__val) => __val,
520 _serde::__private::Err(__err) => {
521 return _serde::__private::Err(__err);
522 }
523 },
524 );
525 }
526 __Field::m_constraintData => {
527 #[cfg(
528 any(feature = "strict", feature = "ignore_duplicates")
529 )]
530 if _serde::__private::Option::is_some(&m_constraintData) {
531 #[cfg(feature = "ignore_duplicates")]
532 {
533 __A::skip_value(&mut __map)?;
534 continue;
535 }
536 #[cfg(feature = "strict")]
537 return _serde::__private::Err(
538 <__A::Error as _serde::de::Error>::duplicate_field(
539 "constraintData",
540 ),
541 );
542 }
543 m_constraintData = _serde::__private::Some(
544 match __A::next_value::<Pointer>(&mut __map) {
545 _serde::__private::Ok(__val) => __val,
546 _serde::__private::Err(__err) => {
547 return _serde::__private::Err(__err);
548 }
549 },
550 );
551 }
552 __Field::m_childRuntimeSize => {
553 #[cfg(
554 any(feature = "strict", feature = "ignore_duplicates")
555 )]
556 if _serde::__private::Option::is_some(&m_childRuntimeSize) {
557 #[cfg(feature = "ignore_duplicates")]
558 {
559 __A::skip_value(&mut __map)?;
560 continue;
561 }
562 #[cfg(feature = "strict")]
563 return _serde::__private::Err(
564 <__A::Error as _serde::de::Error>::duplicate_field(
565 "childRuntimeSize",
566 ),
567 );
568 }
569 m_childRuntimeSize = _serde::__private::Some(
570 match __A::next_value::<u16>(&mut __map) {
571 _serde::__private::Ok(__val) => __val,
572 _serde::__private::Err(__err) => {
573 return _serde::__private::Err(__err);
574 }
575 },
576 );
577 }
578 __Field::m_childNumSolverResults => {
579 #[cfg(
580 any(feature = "strict", feature = "ignore_duplicates")
581 )]
582 if _serde::__private::Option::is_some(
583 &m_childNumSolverResults,
584 ) {
585 #[cfg(feature = "ignore_duplicates")]
586 {
587 __A::skip_value(&mut __map)?;
588 continue;
589 }
590 #[cfg(feature = "strict")]
591 return _serde::__private::Err(
592 <__A::Error as _serde::de::Error>::duplicate_field(
593 "childNumSolverResults",
594 ),
595 );
596 }
597 m_childNumSolverResults = _serde::__private::Some(
598 match __A::next_value::<u16>(&mut __map) {
599 _serde::__private::Ok(__val) => __val,
600 _serde::__private::Err(__err) => {
601 return _serde::__private::Err(__err);
602 }
603 },
604 );
605 }
606 __Field::m_solverResultLimit => {
607 #[cfg(
608 any(feature = "strict", feature = "ignore_duplicates")
609 )]
610 if _serde::__private::Option::is_some(
611 &m_solverResultLimit,
612 ) {
613 #[cfg(feature = "ignore_duplicates")]
614 {
615 __A::skip_value(&mut __map)?;
616 continue;
617 }
618 #[cfg(feature = "strict")]
619 return _serde::__private::Err(
620 <__A::Error as _serde::de::Error>::duplicate_field(
621 "solverResultLimit",
622 ),
623 );
624 }
625 m_solverResultLimit = _serde::__private::Some(
626 match __A::next_value::<f32>(&mut __map) {
627 _serde::__private::Ok(__val) => __val,
628 _serde::__private::Err(__err) => {
629 return _serde::__private::Err(__err);
630 }
631 },
632 );
633 }
634 __Field::m_removeWhenBroken => {
635 #[cfg(
636 any(feature = "strict", feature = "ignore_duplicates")
637 )]
638 if _serde::__private::Option::is_some(&m_removeWhenBroken) {
639 #[cfg(feature = "ignore_duplicates")]
640 {
641 __A::skip_value(&mut __map)?;
642 continue;
643 }
644 #[cfg(feature = "strict")]
645 return _serde::__private::Err(
646 <__A::Error as _serde::de::Error>::duplicate_field(
647 "removeWhenBroken",
648 ),
649 );
650 }
651 m_removeWhenBroken = _serde::__private::Some(
652 match __A::next_value::<bool>(&mut __map) {
653 _serde::__private::Ok(__val) => __val,
654 _serde::__private::Err(__err) => {
655 return _serde::__private::Err(__err);
656 }
657 },
658 );
659 }
660 __Field::m_revertBackVelocityOnBreak => {
661 #[cfg(
662 any(feature = "strict", feature = "ignore_duplicates")
663 )]
664 if _serde::__private::Option::is_some(
665 &m_revertBackVelocityOnBreak,
666 ) {
667 #[cfg(feature = "ignore_duplicates")]
668 {
669 __A::skip_value(&mut __map)?;
670 continue;
671 }
672 #[cfg(feature = "strict")]
673 return _serde::__private::Err(
674 <__A::Error as _serde::de::Error>::duplicate_field(
675 "revertBackVelocityOnBreak",
676 ),
677 );
678 }
679 m_revertBackVelocityOnBreak = _serde::__private::Some(
680 match __A::next_value::<bool>(&mut __map) {
681 _serde::__private::Ok(__val) => __val,
682 _serde::__private::Err(__err) => {
683 return _serde::__private::Err(__err);
684 }
685 },
686 );
687 }
688 _ => __A::skip_value(&mut __map)?,
689 }
690 }
691 let m_userData = match m_userData {
692 _serde::__private::Some(__field) => __field,
693 _serde::__private::None => {
694 #[cfg(feature = "strict")]
695 return _serde::__private::Err(
696 <__A::Error as _serde::de::Error>::missing_field("userData"),
697 );
698 #[cfg(not(feature = "strict"))] Default::default()
699 }
700 };
701 let m_atoms = match m_atoms {
702 _serde::__private::Some(__field) => __field,
703 _serde::__private::None => {
704 #[cfg(feature = "strict")]
705 return _serde::__private::Err(
706 <__A::Error as _serde::de::Error>::missing_field("atoms"),
707 );
708 #[cfg(not(feature = "strict"))] Default::default()
709 }
710 };
711 let m_constraintData = match m_constraintData {
712 _serde::__private::Some(__field) => __field,
713 _serde::__private::None => {
714 #[cfg(feature = "strict")]
715 return _serde::__private::Err(
716 <__A::Error as _serde::de::Error>::missing_field(
717 "constraintData",
718 ),
719 );
720 #[cfg(not(feature = "strict"))] Default::default()
721 }
722 };
723 let m_childRuntimeSize = match m_childRuntimeSize {
724 _serde::__private::Some(__field) => __field,
725 _serde::__private::None => {
726 #[cfg(feature = "strict")]
727 return _serde::__private::Err(
728 <__A::Error as _serde::de::Error>::missing_field(
729 "childRuntimeSize",
730 ),
731 );
732 #[cfg(not(feature = "strict"))] Default::default()
733 }
734 };
735 let m_childNumSolverResults = match m_childNumSolverResults {
736 _serde::__private::Some(__field) => __field,
737 _serde::__private::None => {
738 #[cfg(feature = "strict")]
739 return _serde::__private::Err(
740 <__A::Error as _serde::de::Error>::missing_field(
741 "childNumSolverResults",
742 ),
743 );
744 #[cfg(not(feature = "strict"))] Default::default()
745 }
746 };
747 let m_solverResultLimit = match m_solverResultLimit {
748 _serde::__private::Some(__field) => __field,
749 _serde::__private::None => {
750 #[cfg(feature = "strict")]
751 return _serde::__private::Err(
752 <__A::Error as _serde::de::Error>::missing_field(
753 "solverResultLimit",
754 ),
755 );
756 #[cfg(not(feature = "strict"))] Default::default()
757 }
758 };
759 let m_removeWhenBroken = match m_removeWhenBroken {
760 _serde::__private::Some(__field) => __field,
761 _serde::__private::None => {
762 #[cfg(feature = "strict")]
763 return _serde::__private::Err(
764 <__A::Error as _serde::de::Error>::missing_field(
765 "removeWhenBroken",
766 ),
767 );
768 #[cfg(not(feature = "strict"))] Default::default()
769 }
770 };
771 let m_revertBackVelocityOnBreak = match m_revertBackVelocityOnBreak {
772 _serde::__private::Some(__field) => __field,
773 _serde::__private::None => {
774 #[cfg(feature = "strict")]
775 return _serde::__private::Err(
776 <__A::Error as _serde::de::Error>::missing_field(
777 "revertBackVelocityOnBreak",
778 ),
779 );
780 #[cfg(not(feature = "strict"))] Default::default()
781 }
782 };
783 let __ptr = None;
784 let parent = hkBaseObject { __ptr };
785 let parent = hkReferencedObject {
786 __ptr,
787 parent,
788 ..Default::default()
789 };
790 let parent = hkpConstraintData {
791 __ptr,
792 parent,
793 m_userData,
794 };
795 let __ptr = __A::class_ptr(&mut __map);
796 _serde::__private::Ok(hkpBreakableConstraintData {
797 __ptr,
798 parent,
799 m_atoms,
800 m_constraintData,
801 m_childRuntimeSize,
802 m_childNumSolverResults,
803 m_solverResultLimit,
804 m_removeWhenBroken,
805 m_revertBackVelocityOnBreak,
806 })
807 }
808 }
809 const FIELDS: &[&str] = &[
810 "atoms",
811 "constraintData",
812 "childRuntimeSize",
813 "childNumSolverResults",
814 "solverResultLimit",
815 "removeWhenBroken",
816 "revertBackVelocityOnBreak",
817 ];
818 _serde::Deserializer::deserialize_struct(
819 deserializer,
820 "hkpBreakableConstraintData",
821 FIELDS,
822 __hkpBreakableConstraintDataVisitor {
823 marker: _serde::__private::PhantomData::<hkpBreakableConstraintData>,
824 lifetime: _serde::__private::PhantomData,
825 },
826 )
827 }
828 }
829};