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