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 hkpPulleyConstraintAtom {
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: hkpConstraintAtom,
30 #[cfg_attr(feature = "json_schema", schemars(rename = "fixedPivotAinWorld"))]
35 #[cfg_attr(feature = "serde", serde(rename = "fixedPivotAinWorld"))]
36 pub m_fixedPivotAinWorld: Vector4,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "fixedPivotBinWorld"))]
42 #[cfg_attr(feature = "serde", serde(rename = "fixedPivotBinWorld"))]
43 pub m_fixedPivotBinWorld: Vector4,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "ropeLength"))]
49 #[cfg_attr(feature = "serde", serde(rename = "ropeLength"))]
50 pub m_ropeLength: f32,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "leverageOnBodyB"))]
56 #[cfg_attr(feature = "serde", serde(rename = "leverageOnBodyB"))]
57 pub m_leverageOnBodyB: f32,
58}
59const _: () = {
60 use havok_serde as _serde;
61 impl _serde::HavokClass for hkpPulleyConstraintAtom {
62 #[inline]
63 fn name(&self) -> &'static str {
64 "hkpPulleyConstraintAtom"
65 }
66 #[inline]
67 fn signature(&self) -> _serde::__private::Signature {
68 _serde::__private::Signature::new(0x94a08848)
69 }
70 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
71 fn deps_indexes(&self) -> Vec<usize> {
72 let mut v = Vec::new();
73 v
74 }
75 }
76 impl _serde::Serialize for hkpPulleyConstraintAtom {
77 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
78 where
79 S: _serde::ser::Serializer,
80 {
81 let class_meta = self
82 .__ptr
83 .map(|name| (name, _serde::__private::Signature::new(0x94a08848)));
84 let mut serializer = __serializer
85 .serialize_struct(
86 "hkpPulleyConstraintAtom",
87 class_meta,
88 (64u64, 64u64),
89 )?;
90 serializer.serialize_field("type", &self.parent.m_type)?;
91 serializer.pad_field([0u8; 14usize].as_slice(), [0u8; 14usize].as_slice())?;
92 serializer
93 .serialize_field("fixedPivotAinWorld", &self.m_fixedPivotAinWorld)?;
94 serializer
95 .serialize_field("fixedPivotBinWorld", &self.m_fixedPivotBinWorld)?;
96 serializer.serialize_field("ropeLength", &self.m_ropeLength)?;
97 serializer.serialize_field("leverageOnBodyB", &self.m_leverageOnBodyB)?;
98 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 8usize].as_slice())?;
99 serializer.end()
100 }
101 }
102};
103#[doc(hidden)]
104#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
105const _: () = {
106 use havok_serde as _serde;
107 #[automatically_derived]
108 impl<'de> _serde::Deserialize<'de> for hkpPulleyConstraintAtom {
109 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
110 where
111 __D: _serde::Deserializer<'de>,
112 {
113 #[allow(non_camel_case_types)]
114 enum __Field {
115 m_type,
116 m_fixedPivotAinWorld,
117 m_fixedPivotBinWorld,
118 m_ropeLength,
119 m_leverageOnBodyB,
120 __ignore,
121 }
122 struct __FieldVisitor;
123 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
124 type Value = __Field;
125 fn expecting(
126 &self,
127 __formatter: &mut core::fmt::Formatter,
128 ) -> core::fmt::Result {
129 core::fmt::Formatter::write_str(__formatter, "field identifier")
130 }
131 #[allow(clippy::match_single_binding)]
133 #[allow(clippy::reversed_empty_ranges)]
134 #[allow(clippy::single_match)]
135 fn visit_key<__E>(
136 self,
137 __value: &str,
138 ) -> core::result::Result<Self::Value, __E>
139 where
140 __E: _serde::de::Error,
141 {
142 match __value {
143 "type" => Ok(__Field::m_type),
144 "fixedPivotAinWorld" => Ok(__Field::m_fixedPivotAinWorld),
145 "fixedPivotBinWorld" => Ok(__Field::m_fixedPivotBinWorld),
146 "ropeLength" => Ok(__Field::m_ropeLength),
147 "leverageOnBodyB" => Ok(__Field::m_leverageOnBodyB),
148 _ => Ok(__Field::__ignore),
149 }
150 }
151 }
152 impl<'de> _serde::Deserialize<'de> for __Field {
153 #[inline]
154 fn deserialize<__D>(
155 __deserializer: __D,
156 ) -> core::result::Result<Self, __D::Error>
157 where
158 __D: _serde::Deserializer<'de>,
159 {
160 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
161 }
162 }
163 struct __hkpPulleyConstraintAtomVisitor<'de> {
164 marker: _serde::__private::PhantomData<hkpPulleyConstraintAtom>,
165 lifetime: _serde::__private::PhantomData<&'de ()>,
166 }
167 #[allow(clippy::match_single_binding)]
168 #[allow(clippy::reversed_empty_ranges)]
169 #[allow(clippy::single_match)]
170 impl<'de> _serde::de::Visitor<'de>
171 for __hkpPulleyConstraintAtomVisitor<'de> {
172 type Value = hkpPulleyConstraintAtom;
173 fn expecting(
174 &self,
175 __formatter: &mut core::fmt::Formatter,
176 ) -> core::fmt::Result {
177 core::fmt::Formatter::write_str(
178 __formatter,
179 "struct hkpPulleyConstraintAtom",
180 )
181 }
182 fn visit_struct_for_bytes<__A>(
183 self,
184 mut __map: __A,
185 ) -> _serde::__private::Result<Self::Value, __A::Error>
186 where
187 __A: _serde::de::MapAccess<'de>,
188 {
189 let __ptr = __A::class_ptr(&mut __map);
190 let parent = __A::parent_value(&mut __map)?;
191 let mut m_fixedPivotAinWorld: _serde::__private::Option<Vector4> = _serde::__private::None;
192 let mut m_fixedPivotBinWorld: _serde::__private::Option<Vector4> = _serde::__private::None;
193 let mut m_ropeLength: _serde::__private::Option<f32> = _serde::__private::None;
194 let mut m_leverageOnBodyB: _serde::__private::Option<f32> = _serde::__private::None;
195 for i in 0..4usize {
196 match i {
197 0usize => {
198 if _serde::__private::Option::is_some(
199 &m_fixedPivotAinWorld,
200 ) {
201 return _serde::__private::Err(
202 <__A::Error as _serde::de::Error>::duplicate_field(
203 "fixedPivotAinWorld",
204 ),
205 );
206 }
207 __A::pad(&mut __map, 14usize, 14usize)?;
208 m_fixedPivotAinWorld = _serde::__private::Some(
209 match __A::next_value::<Vector4>(&mut __map) {
210 _serde::__private::Ok(__val) => __val,
211 _serde::__private::Err(__err) => {
212 return _serde::__private::Err(__err);
213 }
214 },
215 );
216 }
217 1usize => {
218 if _serde::__private::Option::is_some(
219 &m_fixedPivotBinWorld,
220 ) {
221 return _serde::__private::Err(
222 <__A::Error as _serde::de::Error>::duplicate_field(
223 "fixedPivotBinWorld",
224 ),
225 );
226 }
227 m_fixedPivotBinWorld = _serde::__private::Some(
228 match __A::next_value::<Vector4>(&mut __map) {
229 _serde::__private::Ok(__val) => __val,
230 _serde::__private::Err(__err) => {
231 return _serde::__private::Err(__err);
232 }
233 },
234 );
235 }
236 2usize => {
237 if _serde::__private::Option::is_some(&m_ropeLength) {
238 return _serde::__private::Err(
239 <__A::Error as _serde::de::Error>::duplicate_field(
240 "ropeLength",
241 ),
242 );
243 }
244 m_ropeLength = _serde::__private::Some(
245 match __A::next_value::<f32>(&mut __map) {
246 _serde::__private::Ok(__val) => __val,
247 _serde::__private::Err(__err) => {
248 return _serde::__private::Err(__err);
249 }
250 },
251 );
252 }
253 3usize => {
254 if _serde::__private::Option::is_some(&m_leverageOnBodyB) {
255 return _serde::__private::Err(
256 <__A::Error as _serde::de::Error>::duplicate_field(
257 "leverageOnBodyB",
258 ),
259 );
260 }
261 m_leverageOnBodyB = _serde::__private::Some(
262 match __A::next_value::<f32>(&mut __map) {
263 _serde::__private::Ok(__val) => __val,
264 _serde::__private::Err(__err) => {
265 return _serde::__private::Err(__err);
266 }
267 },
268 );
269 }
270 _ => {}
271 }
272 }
273 __A::pad(&mut __map, 8usize, 8usize)?;
274 let m_fixedPivotAinWorld = match m_fixedPivotAinWorld {
275 _serde::__private::Some(__field) => __field,
276 _serde::__private::None => {
277 return _serde::__private::Err(
278 <__A::Error as _serde::de::Error>::missing_field(
279 "fixedPivotAinWorld",
280 ),
281 );
282 }
283 };
284 let m_fixedPivotBinWorld = match m_fixedPivotBinWorld {
285 _serde::__private::Some(__field) => __field,
286 _serde::__private::None => {
287 return _serde::__private::Err(
288 <__A::Error as _serde::de::Error>::missing_field(
289 "fixedPivotBinWorld",
290 ),
291 );
292 }
293 };
294 let m_ropeLength = match m_ropeLength {
295 _serde::__private::Some(__field) => __field,
296 _serde::__private::None => {
297 return _serde::__private::Err(
298 <__A::Error as _serde::de::Error>::missing_field(
299 "ropeLength",
300 ),
301 );
302 }
303 };
304 let m_leverageOnBodyB = match m_leverageOnBodyB {
305 _serde::__private::Some(__field) => __field,
306 _serde::__private::None => {
307 return _serde::__private::Err(
308 <__A::Error as _serde::de::Error>::missing_field(
309 "leverageOnBodyB",
310 ),
311 );
312 }
313 };
314 _serde::__private::Ok(hkpPulleyConstraintAtom {
315 __ptr,
316 parent,
317 m_fixedPivotAinWorld,
318 m_fixedPivotBinWorld,
319 m_ropeLength,
320 m_leverageOnBodyB,
321 })
322 }
323 #[allow(clippy::manual_unwrap_or_default)]
324 fn visit_struct<__A>(
325 self,
326 mut __map: __A,
327 ) -> _serde::__private::Result<Self::Value, __A::Error>
328 where
329 __A: _serde::de::MapAccess<'de>,
330 {
331 let mut m_type: _serde::__private::Option<AtomType> = _serde::__private::None;
332 let mut m_fixedPivotAinWorld: _serde::__private::Option<Vector4> = _serde::__private::None;
333 let mut m_fixedPivotBinWorld: _serde::__private::Option<Vector4> = _serde::__private::None;
334 let mut m_ropeLength: _serde::__private::Option<f32> = _serde::__private::None;
335 let mut m_leverageOnBodyB: _serde::__private::Option<f32> = _serde::__private::None;
336 while let _serde::__private::Some(__key) = {
337 __A::next_key::<__Field>(&mut __map)?
338 } {
339 match __key {
340 __Field::m_type => {
341 #[cfg(
342 any(feature = "strict", feature = "ignore_duplicates")
343 )]
344 if _serde::__private::Option::is_some(&m_type) {
345 #[cfg(feature = "ignore_duplicates")]
346 {
347 __A::skip_value(&mut __map)?;
348 continue;
349 }
350 #[cfg(feature = "strict")]
351 return _serde::__private::Err(
352 <__A::Error as _serde::de::Error>::duplicate_field("type"),
353 );
354 }
355 m_type = _serde::__private::Some(
356 match __A::next_value::<AtomType>(&mut __map) {
357 _serde::__private::Ok(__val) => __val,
358 _serde::__private::Err(__err) => {
359 return _serde::__private::Err(__err);
360 }
361 },
362 );
363 }
364 __Field::m_fixedPivotAinWorld => {
365 #[cfg(
366 any(feature = "strict", feature = "ignore_duplicates")
367 )]
368 if _serde::__private::Option::is_some(
369 &m_fixedPivotAinWorld,
370 ) {
371 #[cfg(feature = "ignore_duplicates")]
372 {
373 __A::skip_value(&mut __map)?;
374 continue;
375 }
376 #[cfg(feature = "strict")]
377 return _serde::__private::Err(
378 <__A::Error as _serde::de::Error>::duplicate_field(
379 "fixedPivotAinWorld",
380 ),
381 );
382 }
383 m_fixedPivotAinWorld = _serde::__private::Some(
384 match __A::next_value::<Vector4>(&mut __map) {
385 _serde::__private::Ok(__val) => __val,
386 _serde::__private::Err(__err) => {
387 return _serde::__private::Err(__err);
388 }
389 },
390 );
391 }
392 __Field::m_fixedPivotBinWorld => {
393 #[cfg(
394 any(feature = "strict", feature = "ignore_duplicates")
395 )]
396 if _serde::__private::Option::is_some(
397 &m_fixedPivotBinWorld,
398 ) {
399 #[cfg(feature = "ignore_duplicates")]
400 {
401 __A::skip_value(&mut __map)?;
402 continue;
403 }
404 #[cfg(feature = "strict")]
405 return _serde::__private::Err(
406 <__A::Error as _serde::de::Error>::duplicate_field(
407 "fixedPivotBinWorld",
408 ),
409 );
410 }
411 m_fixedPivotBinWorld = _serde::__private::Some(
412 match __A::next_value::<Vector4>(&mut __map) {
413 _serde::__private::Ok(__val) => __val,
414 _serde::__private::Err(__err) => {
415 return _serde::__private::Err(__err);
416 }
417 },
418 );
419 }
420 __Field::m_ropeLength => {
421 #[cfg(
422 any(feature = "strict", feature = "ignore_duplicates")
423 )]
424 if _serde::__private::Option::is_some(&m_ropeLength) {
425 #[cfg(feature = "ignore_duplicates")]
426 {
427 __A::skip_value(&mut __map)?;
428 continue;
429 }
430 #[cfg(feature = "strict")]
431 return _serde::__private::Err(
432 <__A::Error as _serde::de::Error>::duplicate_field(
433 "ropeLength",
434 ),
435 );
436 }
437 m_ropeLength = _serde::__private::Some(
438 match __A::next_value::<f32>(&mut __map) {
439 _serde::__private::Ok(__val) => __val,
440 _serde::__private::Err(__err) => {
441 return _serde::__private::Err(__err);
442 }
443 },
444 );
445 }
446 __Field::m_leverageOnBodyB => {
447 #[cfg(
448 any(feature = "strict", feature = "ignore_duplicates")
449 )]
450 if _serde::__private::Option::is_some(&m_leverageOnBodyB) {
451 #[cfg(feature = "ignore_duplicates")]
452 {
453 __A::skip_value(&mut __map)?;
454 continue;
455 }
456 #[cfg(feature = "strict")]
457 return _serde::__private::Err(
458 <__A::Error as _serde::de::Error>::duplicate_field(
459 "leverageOnBodyB",
460 ),
461 );
462 }
463 m_leverageOnBodyB = _serde::__private::Some(
464 match __A::next_value::<f32>(&mut __map) {
465 _serde::__private::Ok(__val) => __val,
466 _serde::__private::Err(__err) => {
467 return _serde::__private::Err(__err);
468 }
469 },
470 );
471 }
472 _ => __A::skip_value(&mut __map)?,
473 }
474 }
475 let m_type = match m_type {
476 _serde::__private::Some(__field) => __field,
477 _serde::__private::None => {
478 #[cfg(feature = "strict")]
479 return _serde::__private::Err(
480 <__A::Error as _serde::de::Error>::missing_field("type"),
481 );
482 #[cfg(not(feature = "strict"))] Default::default()
483 }
484 };
485 let m_fixedPivotAinWorld = match m_fixedPivotAinWorld {
486 _serde::__private::Some(__field) => __field,
487 _serde::__private::None => {
488 #[cfg(feature = "strict")]
489 return _serde::__private::Err(
490 <__A::Error as _serde::de::Error>::missing_field(
491 "fixedPivotAinWorld",
492 ),
493 );
494 #[cfg(not(feature = "strict"))] Default::default()
495 }
496 };
497 let m_fixedPivotBinWorld = match m_fixedPivotBinWorld {
498 _serde::__private::Some(__field) => __field,
499 _serde::__private::None => {
500 #[cfg(feature = "strict")]
501 return _serde::__private::Err(
502 <__A::Error as _serde::de::Error>::missing_field(
503 "fixedPivotBinWorld",
504 ),
505 );
506 #[cfg(not(feature = "strict"))] Default::default()
507 }
508 };
509 let m_ropeLength = match m_ropeLength {
510 _serde::__private::Some(__field) => __field,
511 _serde::__private::None => {
512 #[cfg(feature = "strict")]
513 return _serde::__private::Err(
514 <__A::Error as _serde::de::Error>::missing_field(
515 "ropeLength",
516 ),
517 );
518 #[cfg(not(feature = "strict"))] Default::default()
519 }
520 };
521 let m_leverageOnBodyB = match m_leverageOnBodyB {
522 _serde::__private::Some(__field) => __field,
523 _serde::__private::None => {
524 #[cfg(feature = "strict")]
525 return _serde::__private::Err(
526 <__A::Error as _serde::de::Error>::missing_field(
527 "leverageOnBodyB",
528 ),
529 );
530 #[cfg(not(feature = "strict"))] Default::default()
531 }
532 };
533 let __ptr = None;
534 let parent = hkpConstraintAtom { __ptr, m_type };
535 let __ptr = __A::class_ptr(&mut __map);
536 _serde::__private::Ok(hkpPulleyConstraintAtom {
537 __ptr,
538 parent,
539 m_fixedPivotAinWorld,
540 m_fixedPivotBinWorld,
541 m_ropeLength,
542 m_leverageOnBodyB,
543 })
544 }
545 }
546 const FIELDS: &[&str] = &[
547 "fixedPivotAinWorld",
548 "fixedPivotBinWorld",
549 "ropeLength",
550 "leverageOnBodyB",
551 ];
552 _serde::Deserializer::deserialize_struct(
553 deserializer,
554 "hkpPulleyConstraintAtom",
555 FIELDS,
556 __hkpPulleyConstraintAtomVisitor {
557 marker: _serde::__private::PhantomData::<hkpPulleyConstraintAtom>,
558 lifetime: _serde::__private::PhantomData,
559 },
560 )
561 }
562 }
563};