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