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 hkpViscousSurfaceModifierConstraintAtom {
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}
31const _: () = {
32 use havok_serde as _serde;
33 impl _serde::HavokClass for hkpViscousSurfaceModifierConstraintAtom {
34 #[inline]
35 fn name(&self) -> &'static str {
36 "hkpViscousSurfaceModifierConstraintAtom"
37 }
38 #[inline]
39 fn signature(&self) -> _serde::__private::Signature {
40 _serde::__private::Signature::new(0x5c6aa14d)
41 }
42 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
43 fn deps_indexes(&self) -> Vec<usize> {
44 let mut v = Vec::new();
45 v.push(self.parent.m_child.get());
46 v
47 }
48 }
49 impl _serde::Serialize for hkpViscousSurfaceModifierConstraintAtom {
50 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
51 where
52 S: _serde::ser::Serializer,
53 {
54 let class_meta = self
55 .__ptr
56 .map(|name| (name, _serde::__private::Signature::new(0x5c6aa14d)));
57 let mut serializer = __serializer
58 .serialize_struct(
59 "hkpViscousSurfaceModifierConstraintAtom",
60 class_meta,
61 (32u64, 48u64),
62 )?;
63 serializer.serialize_field("type", &self.parent.parent.m_type)?;
64 serializer.pad_field([0u8; 14usize].as_slice(), [0u8; 14usize].as_slice())?;
65 serializer
66 .serialize_field("modifierAtomSize", &self.parent.m_modifierAtomSize)?;
67 serializer.serialize_field("childSize", &self.parent.m_childSize)?;
68 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
69 serializer.serialize_field("child", &self.parent.m_child)?;
70 serializer
71 .serialize_fixed_array_field(
72 "pad",
73 self.parent.m_pad.as_slice(),
74 TypeSize::NonPtr,
75 )?;
76 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 8usize].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 hkpViscousSurfaceModifierConstraintAtom {
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_type,
94 m_modifierAtomSize,
95 m_childSize,
96 m_child,
97 m_pad,
98 __ignore,
99 }
100 struct __FieldVisitor;
101 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
102 type Value = __Field;
103 fn expecting(
104 &self,
105 __formatter: &mut core::fmt::Formatter,
106 ) -> core::fmt::Result {
107 core::fmt::Formatter::write_str(__formatter, "field identifier")
108 }
109 #[allow(clippy::match_single_binding)]
111 #[allow(clippy::reversed_empty_ranges)]
112 #[allow(clippy::single_match)]
113 fn visit_key<__E>(
114 self,
115 __value: &str,
116 ) -> core::result::Result<Self::Value, __E>
117 where
118 __E: _serde::de::Error,
119 {
120 match __value {
121 "type" => Ok(__Field::m_type),
122 "modifierAtomSize" => Ok(__Field::m_modifierAtomSize),
123 "childSize" => Ok(__Field::m_childSize),
124 "child" => Ok(__Field::m_child),
125 "pad" => Ok(__Field::m_pad),
126 _ => Ok(__Field::__ignore),
127 }
128 }
129 }
130 impl<'de> _serde::Deserialize<'de> for __Field {
131 #[inline]
132 fn deserialize<__D>(
133 __deserializer: __D,
134 ) -> core::result::Result<Self, __D::Error>
135 where
136 __D: _serde::Deserializer<'de>,
137 {
138 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
139 }
140 }
141 struct __hkpViscousSurfaceModifierConstraintAtomVisitor<'de> {
142 marker: _serde::__private::PhantomData<
143 hkpViscousSurfaceModifierConstraintAtom,
144 >,
145 lifetime: _serde::__private::PhantomData<&'de ()>,
146 }
147 #[allow(clippy::match_single_binding)]
148 #[allow(clippy::reversed_empty_ranges)]
149 #[allow(clippy::single_match)]
150 impl<'de> _serde::de::Visitor<'de>
151 for __hkpViscousSurfaceModifierConstraintAtomVisitor<'de> {
152 type Value = hkpViscousSurfaceModifierConstraintAtom;
153 fn expecting(
154 &self,
155 __formatter: &mut core::fmt::Formatter,
156 ) -> core::fmt::Result {
157 core::fmt::Formatter::write_str(
158 __formatter,
159 "struct hkpViscousSurfaceModifierConstraintAtom",
160 )
161 }
162 fn visit_struct_for_bytes<__A>(
163 self,
164 mut __map: __A,
165 ) -> _serde::__private::Result<Self::Value, __A::Error>
166 where
167 __A: _serde::de::MapAccess<'de>,
168 {
169 let __ptr = __A::class_ptr(&mut __map);
170 let parent = __A::parent_value(&mut __map)?;
171 for i in 0..0usize {
172 match i {
173 _ => {}
174 }
175 }
176 _serde::__private::Ok(hkpViscousSurfaceModifierConstraintAtom {
177 __ptr,
178 parent,
179 })
180 }
181 #[allow(clippy::manual_unwrap_or_default)]
182 fn visit_struct<__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 mut m_type: _serde::__private::Option<AtomType> = _serde::__private::None;
190 let mut m_modifierAtomSize: _serde::__private::Option<u16> = _serde::__private::None;
191 let mut m_childSize: _serde::__private::Option<u16> = _serde::__private::None;
192 let mut m_child: _serde::__private::Option<Pointer> = _serde::__private::None;
193 let mut m_pad: _serde::__private::Option<[u32; 2usize]> = _serde::__private::None;
194 while let _serde::__private::Some(__key) = {
195 __A::next_key::<__Field>(&mut __map)?
196 } {
197 match __key {
198 __Field::m_type => {
199 #[cfg(
200 any(feature = "strict", feature = "ignore_duplicates")
201 )]
202 if _serde::__private::Option::is_some(&m_type) {
203 #[cfg(feature = "ignore_duplicates")]
204 {
205 __A::skip_value(&mut __map)?;
206 continue;
207 }
208 #[cfg(feature = "strict")]
209 return _serde::__private::Err(
210 <__A::Error as _serde::de::Error>::duplicate_field("type"),
211 );
212 }
213 m_type = _serde::__private::Some(
214 match __A::next_value::<AtomType>(&mut __map) {
215 _serde::__private::Ok(__val) => __val,
216 _serde::__private::Err(__err) => {
217 return _serde::__private::Err(__err);
218 }
219 },
220 );
221 }
222 __Field::m_modifierAtomSize => {
223 #[cfg(
224 any(feature = "strict", feature = "ignore_duplicates")
225 )]
226 if _serde::__private::Option::is_some(&m_modifierAtomSize) {
227 #[cfg(feature = "ignore_duplicates")]
228 {
229 __A::skip_value(&mut __map)?;
230 continue;
231 }
232 #[cfg(feature = "strict")]
233 return _serde::__private::Err(
234 <__A::Error as _serde::de::Error>::duplicate_field(
235 "modifierAtomSize",
236 ),
237 );
238 }
239 m_modifierAtomSize = _serde::__private::Some(
240 match __A::next_value::<u16>(&mut __map) {
241 _serde::__private::Ok(__val) => __val,
242 _serde::__private::Err(__err) => {
243 return _serde::__private::Err(__err);
244 }
245 },
246 );
247 }
248 __Field::m_childSize => {
249 #[cfg(
250 any(feature = "strict", feature = "ignore_duplicates")
251 )]
252 if _serde::__private::Option::is_some(&m_childSize) {
253 #[cfg(feature = "ignore_duplicates")]
254 {
255 __A::skip_value(&mut __map)?;
256 continue;
257 }
258 #[cfg(feature = "strict")]
259 return _serde::__private::Err(
260 <__A::Error as _serde::de::Error>::duplicate_field(
261 "childSize",
262 ),
263 );
264 }
265 m_childSize = _serde::__private::Some(
266 match __A::next_value::<u16>(&mut __map) {
267 _serde::__private::Ok(__val) => __val,
268 _serde::__private::Err(__err) => {
269 return _serde::__private::Err(__err);
270 }
271 },
272 );
273 }
274 __Field::m_child => {
275 #[cfg(
276 any(feature = "strict", feature = "ignore_duplicates")
277 )]
278 if _serde::__private::Option::is_some(&m_child) {
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("child"),
287 );
288 }
289 m_child = _serde::__private::Some(
290 match __A::next_value::<Pointer>(&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_pad => {
299 #[cfg(
300 any(feature = "strict", feature = "ignore_duplicates")
301 )]
302 if _serde::__private::Option::is_some(&m_pad) {
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("pad"),
311 );
312 }
313 m_pad = _serde::__private::Some(
314 match __A::next_value::<[u32; 2usize]>(&mut __map) {
315 _serde::__private::Ok(__val) => __val,
316 _serde::__private::Err(__err) => {
317 return _serde::__private::Err(__err);
318 }
319 },
320 );
321 }
322 _ => __A::skip_value(&mut __map)?,
323 }
324 }
325 let m_type = match m_type {
326 _serde::__private::Some(__field) => __field,
327 _serde::__private::None => {
328 #[cfg(feature = "strict")]
329 return _serde::__private::Err(
330 <__A::Error as _serde::de::Error>::missing_field("type"),
331 );
332 #[cfg(not(feature = "strict"))] Default::default()
333 }
334 };
335 let m_modifierAtomSize = match m_modifierAtomSize {
336 _serde::__private::Some(__field) => __field,
337 _serde::__private::None => {
338 #[cfg(feature = "strict")]
339 return _serde::__private::Err(
340 <__A::Error as _serde::de::Error>::missing_field(
341 "modifierAtomSize",
342 ),
343 );
344 #[cfg(not(feature = "strict"))] Default::default()
345 }
346 };
347 let m_childSize = match m_childSize {
348 _serde::__private::Some(__field) => __field,
349 _serde::__private::None => {
350 #[cfg(feature = "strict")]
351 return _serde::__private::Err(
352 <__A::Error as _serde::de::Error>::missing_field(
353 "childSize",
354 ),
355 );
356 #[cfg(not(feature = "strict"))] Default::default()
357 }
358 };
359 let m_child = match m_child {
360 _serde::__private::Some(__field) => __field,
361 _serde::__private::None => {
362 #[cfg(feature = "strict")]
363 return _serde::__private::Err(
364 <__A::Error as _serde::de::Error>::missing_field("child"),
365 );
366 #[cfg(not(feature = "strict"))] Default::default()
367 }
368 };
369 let m_pad = match m_pad {
370 _serde::__private::Some(__field) => __field,
371 _serde::__private::None => {
372 #[cfg(feature = "strict")]
373 return _serde::__private::Err(
374 <__A::Error as _serde::de::Error>::missing_field("pad"),
375 );
376 #[cfg(not(feature = "strict"))] Default::default()
377 }
378 };
379 let __ptr = None;
380 let parent = hkpConstraintAtom { __ptr, m_type };
381 let parent = hkpModifierConstraintAtom {
382 __ptr,
383 parent,
384 m_modifierAtomSize,
385 m_childSize,
386 m_child,
387 m_pad,
388 };
389 let __ptr = __A::class_ptr(&mut __map);
390 _serde::__private::Ok(hkpViscousSurfaceModifierConstraintAtom {
391 __ptr,
392 parent,
393 })
394 }
395 }
396 const FIELDS: &[&str] = &[];
397 _serde::Deserializer::deserialize_struct(
398 deserializer,
399 "hkpViscousSurfaceModifierConstraintAtom",
400 FIELDS,
401 __hkpViscousSurfaceModifierConstraintAtomVisitor {
402 marker: _serde::__private::PhantomData::<
403 hkpViscousSurfaceModifierConstraintAtom,
404 >,
405 lifetime: _serde::__private::PhantomData,
406 },
407 )
408 }
409 }
410};