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