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