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 hkpRackAndPinionConstraintDataAtoms {
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 = "rackAndPinion"))]
38 #[cfg_attr(feature = "serde", serde(rename = "rackAndPinion"))]
39 pub m_rackAndPinion: hkpRackAndPinionConstraintAtom,
40}
41const _: () = {
42 use havok_serde as _serde;
43 impl _serde::HavokClass for hkpRackAndPinionConstraintDataAtoms {
44 #[inline]
45 fn name(&self) -> &'static str {
46 "hkpRackAndPinionConstraintDataAtoms"
47 }
48 #[inline]
49 fn signature(&self) -> _serde::__private::Signature {
50 _serde::__private::Signature::new(0xa58a9659)
51 }
52 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
53 fn deps_indexes(&self) -> Vec<usize> {
54 let mut v = Vec::new();
55 v.extend(self.m_transforms.deps_indexes());
56 v.extend(self.m_rackAndPinion.deps_indexes());
57 v
58 }
59 }
60 impl _serde::Serialize for hkpRackAndPinionConstraintDataAtoms {
61 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
62 where
63 S: _serde::ser::Serializer,
64 {
65 let class_meta = self
66 .__ptr
67 .map(|name| (name, _serde::__private::Signature::new(0xa58a9659)));
68 let mut serializer = __serializer
69 .serialize_struct(
70 "hkpRackAndPinionConstraintDataAtoms",
71 class_meta,
72 (160u64, 160u64),
73 )?;
74 serializer.serialize_field("transforms", &self.m_transforms)?;
75 serializer.serialize_field("rackAndPinion", &self.m_rackAndPinion)?;
76 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 4usize].as_slice())?;
77 serializer.end()
78 }
79 }
80};
81#[doc(hidden)]
82#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
83const _: () = {
84 use havok_serde as _serde;
85 #[automatically_derived]
86 impl<'de> _serde::Deserialize<'de> for hkpRackAndPinionConstraintDataAtoms {
87 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
88 where
89 __D: _serde::Deserializer<'de>,
90 {
91 #[allow(non_camel_case_types)]
92 enum __Field {
93 m_transforms,
94 m_rackAndPinion,
95 __ignore,
96 }
97 struct __FieldVisitor;
98 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
99 type Value = __Field;
100 fn expecting(
101 &self,
102 __formatter: &mut core::fmt::Formatter,
103 ) -> core::fmt::Result {
104 core::fmt::Formatter::write_str(__formatter, "field identifier")
105 }
106 #[allow(clippy::match_single_binding)]
108 #[allow(clippy::reversed_empty_ranges)]
109 #[allow(clippy::single_match)]
110 fn visit_key<__E>(
111 self,
112 __value: &str,
113 ) -> core::result::Result<Self::Value, __E>
114 where
115 __E: _serde::de::Error,
116 {
117 match __value {
118 "transforms" => Ok(__Field::m_transforms),
119 "rackAndPinion" => Ok(__Field::m_rackAndPinion),
120 _ => Ok(__Field::__ignore),
121 }
122 }
123 }
124 impl<'de> _serde::Deserialize<'de> for __Field {
125 #[inline]
126 fn deserialize<__D>(
127 __deserializer: __D,
128 ) -> core::result::Result<Self, __D::Error>
129 where
130 __D: _serde::Deserializer<'de>,
131 {
132 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
133 }
134 }
135 struct __hkpRackAndPinionConstraintDataAtomsVisitor<'de> {
136 marker: _serde::__private::PhantomData<
137 hkpRackAndPinionConstraintDataAtoms,
138 >,
139 lifetime: _serde::__private::PhantomData<&'de ()>,
140 }
141 #[allow(clippy::match_single_binding)]
142 #[allow(clippy::reversed_empty_ranges)]
143 #[allow(clippy::single_match)]
144 impl<'de> _serde::de::Visitor<'de>
145 for __hkpRackAndPinionConstraintDataAtomsVisitor<'de> {
146 type Value = hkpRackAndPinionConstraintDataAtoms;
147 fn expecting(
148 &self,
149 __formatter: &mut core::fmt::Formatter,
150 ) -> core::fmt::Result {
151 core::fmt::Formatter::write_str(
152 __formatter,
153 "struct hkpRackAndPinionConstraintDataAtoms",
154 )
155 }
156 fn visit_struct_for_bytes<__A>(
157 self,
158 mut __map: __A,
159 ) -> _serde::__private::Result<Self::Value, __A::Error>
160 where
161 __A: _serde::de::MapAccess<'de>,
162 {
163 let __ptr = __A::class_ptr(&mut __map);
164 let mut m_transforms: _serde::__private::Option<
165 hkpSetLocalTransformsConstraintAtom,
166 > = _serde::__private::None;
167 let mut m_rackAndPinion: _serde::__private::Option<
168 hkpRackAndPinionConstraintAtom,
169 > = _serde::__private::None;
170 for i in 0..2usize {
171 match i {
172 0usize => {
173 if _serde::__private::Option::is_some(&m_transforms) {
174 return _serde::__private::Err(
175 <__A::Error as _serde::de::Error>::duplicate_field(
176 "transforms",
177 ),
178 );
179 }
180 m_transforms = _serde::__private::Some(
181 match __A::next_value::<
182 hkpSetLocalTransformsConstraintAtom,
183 >(&mut __map) {
184 _serde::__private::Ok(__val) => __val,
185 _serde::__private::Err(__err) => {
186 return _serde::__private::Err(__err);
187 }
188 },
189 );
190 }
191 1usize => {
192 if _serde::__private::Option::is_some(&m_rackAndPinion) {
193 return _serde::__private::Err(
194 <__A::Error as _serde::de::Error>::duplicate_field(
195 "rackAndPinion",
196 ),
197 );
198 }
199 m_rackAndPinion = _serde::__private::Some(
200 match __A::next_value::<
201 hkpRackAndPinionConstraintAtom,
202 >(&mut __map) {
203 _serde::__private::Ok(__val) => __val,
204 _serde::__private::Err(__err) => {
205 return _serde::__private::Err(__err);
206 }
207 },
208 );
209 }
210 _ => {}
211 }
212 }
213 __A::pad(&mut __map, 4usize, 4usize)?;
214 let m_transforms = match m_transforms {
215 _serde::__private::Some(__field) => __field,
216 _serde::__private::None => {
217 return _serde::__private::Err(
218 <__A::Error as _serde::de::Error>::missing_field(
219 "transforms",
220 ),
221 );
222 }
223 };
224 let m_rackAndPinion = match m_rackAndPinion {
225 _serde::__private::Some(__field) => __field,
226 _serde::__private::None => {
227 return _serde::__private::Err(
228 <__A::Error as _serde::de::Error>::missing_field(
229 "rackAndPinion",
230 ),
231 );
232 }
233 };
234 _serde::__private::Ok(hkpRackAndPinionConstraintDataAtoms {
235 __ptr,
236 m_transforms,
237 m_rackAndPinion,
238 })
239 }
240 #[allow(clippy::manual_unwrap_or_default)]
241 fn visit_struct<__A>(
242 self,
243 mut __map: __A,
244 ) -> _serde::__private::Result<Self::Value, __A::Error>
245 where
246 __A: _serde::de::MapAccess<'de>,
247 {
248 let mut m_transforms: _serde::__private::Option<
249 hkpSetLocalTransformsConstraintAtom,
250 > = _serde::__private::None;
251 let mut m_rackAndPinion: _serde::__private::Option<
252 hkpRackAndPinionConstraintAtom,
253 > = _serde::__private::None;
254 while let _serde::__private::Some(__key) = {
255 __A::next_key::<__Field>(&mut __map)?
256 } {
257 match __key {
258 __Field::m_transforms => {
259 #[cfg(
260 any(feature = "strict", feature = "ignore_duplicates")
261 )]
262 if _serde::__private::Option::is_some(&m_transforms) {
263 #[cfg(feature = "ignore_duplicates")]
264 {
265 __A::skip_value(&mut __map)?;
266 continue;
267 }
268 #[cfg(feature = "strict")]
269 return _serde::__private::Err(
270 <__A::Error as _serde::de::Error>::duplicate_field(
271 "transforms",
272 ),
273 );
274 }
275 m_transforms = _serde::__private::Some(
276 match __A::next_value::<
277 hkpSetLocalTransformsConstraintAtom,
278 >(&mut __map) {
279 _serde::__private::Ok(__val) => __val,
280 _serde::__private::Err(__err) => {
281 return _serde::__private::Err(__err);
282 }
283 },
284 );
285 }
286 __Field::m_rackAndPinion => {
287 #[cfg(
288 any(feature = "strict", feature = "ignore_duplicates")
289 )]
290 if _serde::__private::Option::is_some(&m_rackAndPinion) {
291 #[cfg(feature = "ignore_duplicates")]
292 {
293 __A::skip_value(&mut __map)?;
294 continue;
295 }
296 #[cfg(feature = "strict")]
297 return _serde::__private::Err(
298 <__A::Error as _serde::de::Error>::duplicate_field(
299 "rackAndPinion",
300 ),
301 );
302 }
303 m_rackAndPinion = _serde::__private::Some(
304 match __A::next_value::<
305 hkpRackAndPinionConstraintAtom,
306 >(&mut __map) {
307 _serde::__private::Ok(__val) => __val,
308 _serde::__private::Err(__err) => {
309 return _serde::__private::Err(__err);
310 }
311 },
312 );
313 }
314 _ => __A::skip_value(&mut __map)?,
315 }
316 }
317 let m_transforms = match m_transforms {
318 _serde::__private::Some(__field) => __field,
319 _serde::__private::None => {
320 #[cfg(feature = "strict")]
321 return _serde::__private::Err(
322 <__A::Error as _serde::de::Error>::missing_field(
323 "transforms",
324 ),
325 );
326 #[cfg(not(feature = "strict"))] Default::default()
327 }
328 };
329 let m_rackAndPinion = match m_rackAndPinion {
330 _serde::__private::Some(__field) => __field,
331 _serde::__private::None => {
332 #[cfg(feature = "strict")]
333 return _serde::__private::Err(
334 <__A::Error as _serde::de::Error>::missing_field(
335 "rackAndPinion",
336 ),
337 );
338 #[cfg(not(feature = "strict"))] Default::default()
339 }
340 };
341 let __ptr = __A::class_ptr(&mut __map);
342 _serde::__private::Ok(hkpRackAndPinionConstraintDataAtoms {
343 __ptr,
344 m_transforms,
345 m_rackAndPinion,
346 })
347 }
348 }
349 const FIELDS: &[&str] = &["transforms", "rackAndPinion"];
350 _serde::Deserializer::deserialize_struct(
351 deserializer,
352 "hkpRackAndPinionConstraintDataAtoms",
353 FIELDS,
354 __hkpRackAndPinionConstraintDataAtomsVisitor {
355 marker: _serde::__private::PhantomData::<
356 hkpRackAndPinionConstraintDataAtoms,
357 >,
358 lifetime: _serde::__private::PhantomData,
359 },
360 )
361 }
362 }
363};