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