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 hkSweptTransform {
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 = "centerOfMass0"))]
31 #[cfg_attr(feature = "serde", serde(rename = "centerOfMass0"))]
32 pub m_centerOfMass0: Vector4,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "centerOfMass1"))]
38 #[cfg_attr(feature = "serde", serde(rename = "centerOfMass1"))]
39 pub m_centerOfMass1: Vector4,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "rotation0"))]
45 #[cfg_attr(feature = "serde", serde(rename = "rotation0"))]
46 pub m_rotation0: Quaternion,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "rotation1"))]
52 #[cfg_attr(feature = "serde", serde(rename = "rotation1"))]
53 pub m_rotation1: Quaternion,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "centerOfMassLocal"))]
59 #[cfg_attr(feature = "serde", serde(rename = "centerOfMassLocal"))]
60 pub m_centerOfMassLocal: Vector4,
61}
62const _: () = {
63 use havok_serde as _serde;
64 impl _serde::HavokClass for hkSweptTransform {
65 #[inline]
66 fn name(&self) -> &'static str {
67 "hkSweptTransform"
68 }
69 #[inline]
70 fn signature(&self) -> _serde::__private::Signature {
71 _serde::__private::Signature::new(0xb4e5770)
72 }
73 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
74 fn deps_indexes(&self) -> Vec<usize> {
75 let mut v = Vec::new();
76 v
77 }
78 }
79 impl _serde::Serialize for hkSweptTransform {
80 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
81 where
82 S: _serde::ser::Serializer,
83 {
84 let class_meta = self
85 .__ptr
86 .map(|name| (name, _serde::__private::Signature::new(0xb4e5770)));
87 let mut serializer = __serializer
88 .serialize_struct("hkSweptTransform", class_meta, (80u64, 80u64))?;
89 serializer.serialize_field("centerOfMass0", &self.m_centerOfMass0)?;
90 serializer.serialize_field("centerOfMass1", &self.m_centerOfMass1)?;
91 serializer.serialize_field("rotation0", &self.m_rotation0)?;
92 serializer.serialize_field("rotation1", &self.m_rotation1)?;
93 serializer.serialize_field("centerOfMassLocal", &self.m_centerOfMassLocal)?;
94 serializer.end()
95 }
96 }
97};
98#[doc(hidden)]
99#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
100const _: () = {
101 use havok_serde as _serde;
102 #[automatically_derived]
103 impl<'de> _serde::Deserialize<'de> for hkSweptTransform {
104 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
105 where
106 __D: _serde::Deserializer<'de>,
107 {
108 #[allow(non_camel_case_types)]
109 enum __Field {
110 m_centerOfMass0,
111 m_centerOfMass1,
112 m_rotation0,
113 m_rotation1,
114 m_centerOfMassLocal,
115 __ignore,
116 }
117 struct __FieldVisitor;
118 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
119 type Value = __Field;
120 fn expecting(
121 &self,
122 __formatter: &mut core::fmt::Formatter,
123 ) -> core::fmt::Result {
124 core::fmt::Formatter::write_str(__formatter, "field identifier")
125 }
126 #[allow(clippy::match_single_binding)]
128 #[allow(clippy::reversed_empty_ranges)]
129 #[allow(clippy::single_match)]
130 fn visit_key<__E>(
131 self,
132 __value: &str,
133 ) -> core::result::Result<Self::Value, __E>
134 where
135 __E: _serde::de::Error,
136 {
137 match __value {
138 "centerOfMass0" => Ok(__Field::m_centerOfMass0),
139 "centerOfMass1" => Ok(__Field::m_centerOfMass1),
140 "rotation0" => Ok(__Field::m_rotation0),
141 "rotation1" => Ok(__Field::m_rotation1),
142 "centerOfMassLocal" => Ok(__Field::m_centerOfMassLocal),
143 _ => Ok(__Field::__ignore),
144 }
145 }
146 }
147 impl<'de> _serde::Deserialize<'de> for __Field {
148 #[inline]
149 fn deserialize<__D>(
150 __deserializer: __D,
151 ) -> core::result::Result<Self, __D::Error>
152 where
153 __D: _serde::Deserializer<'de>,
154 {
155 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
156 }
157 }
158 struct __hkSweptTransformVisitor<'de> {
159 marker: _serde::__private::PhantomData<hkSweptTransform>,
160 lifetime: _serde::__private::PhantomData<&'de ()>,
161 }
162 #[allow(clippy::match_single_binding)]
163 #[allow(clippy::reversed_empty_ranges)]
164 #[allow(clippy::single_match)]
165 impl<'de> _serde::de::Visitor<'de> for __hkSweptTransformVisitor<'de> {
166 type Value = hkSweptTransform;
167 fn expecting(
168 &self,
169 __formatter: &mut core::fmt::Formatter,
170 ) -> core::fmt::Result {
171 core::fmt::Formatter::write_str(
172 __formatter,
173 "struct hkSweptTransform",
174 )
175 }
176 fn visit_struct_for_bytes<__A>(
177 self,
178 mut __map: __A,
179 ) -> _serde::__private::Result<Self::Value, __A::Error>
180 where
181 __A: _serde::de::MapAccess<'de>,
182 {
183 let __ptr = __A::class_ptr(&mut __map);
184 let mut m_centerOfMass0: _serde::__private::Option<Vector4> = _serde::__private::None;
185 let mut m_centerOfMass1: _serde::__private::Option<Vector4> = _serde::__private::None;
186 let mut m_rotation0: _serde::__private::Option<Quaternion> = _serde::__private::None;
187 let mut m_rotation1: _serde::__private::Option<Quaternion> = _serde::__private::None;
188 let mut m_centerOfMassLocal: _serde::__private::Option<Vector4> = _serde::__private::None;
189 for i in 0..5usize {
190 match i {
191 0usize => {
192 if _serde::__private::Option::is_some(&m_centerOfMass0) {
193 return _serde::__private::Err(
194 <__A::Error as _serde::de::Error>::duplicate_field(
195 "centerOfMass0",
196 ),
197 );
198 }
199 m_centerOfMass0 = _serde::__private::Some(
200 match __A::next_value::<Vector4>(&mut __map) {
201 _serde::__private::Ok(__val) => __val,
202 _serde::__private::Err(__err) => {
203 return _serde::__private::Err(__err);
204 }
205 },
206 );
207 }
208 1usize => {
209 if _serde::__private::Option::is_some(&m_centerOfMass1) {
210 return _serde::__private::Err(
211 <__A::Error as _serde::de::Error>::duplicate_field(
212 "centerOfMass1",
213 ),
214 );
215 }
216 m_centerOfMass1 = _serde::__private::Some(
217 match __A::next_value::<Vector4>(&mut __map) {
218 _serde::__private::Ok(__val) => __val,
219 _serde::__private::Err(__err) => {
220 return _serde::__private::Err(__err);
221 }
222 },
223 );
224 }
225 2usize => {
226 if _serde::__private::Option::is_some(&m_rotation0) {
227 return _serde::__private::Err(
228 <__A::Error as _serde::de::Error>::duplicate_field(
229 "rotation0",
230 ),
231 );
232 }
233 m_rotation0 = _serde::__private::Some(
234 match __A::next_value::<Quaternion>(&mut __map) {
235 _serde::__private::Ok(__val) => __val,
236 _serde::__private::Err(__err) => {
237 return _serde::__private::Err(__err);
238 }
239 },
240 );
241 }
242 3usize => {
243 if _serde::__private::Option::is_some(&m_rotation1) {
244 return _serde::__private::Err(
245 <__A::Error as _serde::de::Error>::duplicate_field(
246 "rotation1",
247 ),
248 );
249 }
250 m_rotation1 = _serde::__private::Some(
251 match __A::next_value::<Quaternion>(&mut __map) {
252 _serde::__private::Ok(__val) => __val,
253 _serde::__private::Err(__err) => {
254 return _serde::__private::Err(__err);
255 }
256 },
257 );
258 }
259 4usize => {
260 if _serde::__private::Option::is_some(
261 &m_centerOfMassLocal,
262 ) {
263 return _serde::__private::Err(
264 <__A::Error as _serde::de::Error>::duplicate_field(
265 "centerOfMassLocal",
266 ),
267 );
268 }
269 m_centerOfMassLocal = _serde::__private::Some(
270 match __A::next_value::<Vector4>(&mut __map) {
271 _serde::__private::Ok(__val) => __val,
272 _serde::__private::Err(__err) => {
273 return _serde::__private::Err(__err);
274 }
275 },
276 );
277 }
278 _ => {}
279 }
280 }
281 let m_centerOfMass0 = match m_centerOfMass0 {
282 _serde::__private::Some(__field) => __field,
283 _serde::__private::None => {
284 return _serde::__private::Err(
285 <__A::Error as _serde::de::Error>::missing_field(
286 "centerOfMass0",
287 ),
288 );
289 }
290 };
291 let m_centerOfMass1 = match m_centerOfMass1 {
292 _serde::__private::Some(__field) => __field,
293 _serde::__private::None => {
294 return _serde::__private::Err(
295 <__A::Error as _serde::de::Error>::missing_field(
296 "centerOfMass1",
297 ),
298 );
299 }
300 };
301 let m_rotation0 = match m_rotation0 {
302 _serde::__private::Some(__field) => __field,
303 _serde::__private::None => {
304 return _serde::__private::Err(
305 <__A::Error as _serde::de::Error>::missing_field(
306 "rotation0",
307 ),
308 );
309 }
310 };
311 let m_rotation1 = match m_rotation1 {
312 _serde::__private::Some(__field) => __field,
313 _serde::__private::None => {
314 return _serde::__private::Err(
315 <__A::Error as _serde::de::Error>::missing_field(
316 "rotation1",
317 ),
318 );
319 }
320 };
321 let m_centerOfMassLocal = match m_centerOfMassLocal {
322 _serde::__private::Some(__field) => __field,
323 _serde::__private::None => {
324 return _serde::__private::Err(
325 <__A::Error as _serde::de::Error>::missing_field(
326 "centerOfMassLocal",
327 ),
328 );
329 }
330 };
331 _serde::__private::Ok(hkSweptTransform {
332 __ptr,
333 m_centerOfMass0,
334 m_centerOfMass1,
335 m_rotation0,
336 m_rotation1,
337 m_centerOfMassLocal,
338 })
339 }
340 #[allow(clippy::manual_unwrap_or_default)]
341 fn visit_struct<__A>(
342 self,
343 mut __map: __A,
344 ) -> _serde::__private::Result<Self::Value, __A::Error>
345 where
346 __A: _serde::de::MapAccess<'de>,
347 {
348 let mut m_centerOfMass0: _serde::__private::Option<Vector4> = _serde::__private::None;
349 let mut m_centerOfMass1: _serde::__private::Option<Vector4> = _serde::__private::None;
350 let mut m_rotation0: _serde::__private::Option<Quaternion> = _serde::__private::None;
351 let mut m_rotation1: _serde::__private::Option<Quaternion> = _serde::__private::None;
352 let mut m_centerOfMassLocal: _serde::__private::Option<Vector4> = _serde::__private::None;
353 while let _serde::__private::Some(__key) = {
354 __A::next_key::<__Field>(&mut __map)?
355 } {
356 match __key {
357 __Field::m_centerOfMass0 => {
358 #[cfg(
359 any(feature = "strict", feature = "ignore_duplicates")
360 )]
361 if _serde::__private::Option::is_some(&m_centerOfMass0) {
362 #[cfg(feature = "ignore_duplicates")]
363 {
364 __A::skip_value(&mut __map)?;
365 continue;
366 }
367 #[cfg(feature = "strict")]
368 return _serde::__private::Err(
369 <__A::Error as _serde::de::Error>::duplicate_field(
370 "centerOfMass0",
371 ),
372 );
373 }
374 m_centerOfMass0 = _serde::__private::Some(
375 match __A::next_value::<Vector4>(&mut __map) {
376 _serde::__private::Ok(__val) => __val,
377 _serde::__private::Err(__err) => {
378 return _serde::__private::Err(__err);
379 }
380 },
381 );
382 }
383 __Field::m_centerOfMass1 => {
384 #[cfg(
385 any(feature = "strict", feature = "ignore_duplicates")
386 )]
387 if _serde::__private::Option::is_some(&m_centerOfMass1) {
388 #[cfg(feature = "ignore_duplicates")]
389 {
390 __A::skip_value(&mut __map)?;
391 continue;
392 }
393 #[cfg(feature = "strict")]
394 return _serde::__private::Err(
395 <__A::Error as _serde::de::Error>::duplicate_field(
396 "centerOfMass1",
397 ),
398 );
399 }
400 m_centerOfMass1 = _serde::__private::Some(
401 match __A::next_value::<Vector4>(&mut __map) {
402 _serde::__private::Ok(__val) => __val,
403 _serde::__private::Err(__err) => {
404 return _serde::__private::Err(__err);
405 }
406 },
407 );
408 }
409 __Field::m_rotation0 => {
410 #[cfg(
411 any(feature = "strict", feature = "ignore_duplicates")
412 )]
413 if _serde::__private::Option::is_some(&m_rotation0) {
414 #[cfg(feature = "ignore_duplicates")]
415 {
416 __A::skip_value(&mut __map)?;
417 continue;
418 }
419 #[cfg(feature = "strict")]
420 return _serde::__private::Err(
421 <__A::Error as _serde::de::Error>::duplicate_field(
422 "rotation0",
423 ),
424 );
425 }
426 m_rotation0 = _serde::__private::Some(
427 match __A::next_value::<Quaternion>(&mut __map) {
428 _serde::__private::Ok(__val) => __val,
429 _serde::__private::Err(__err) => {
430 return _serde::__private::Err(__err);
431 }
432 },
433 );
434 }
435 __Field::m_rotation1 => {
436 #[cfg(
437 any(feature = "strict", feature = "ignore_duplicates")
438 )]
439 if _serde::__private::Option::is_some(&m_rotation1) {
440 #[cfg(feature = "ignore_duplicates")]
441 {
442 __A::skip_value(&mut __map)?;
443 continue;
444 }
445 #[cfg(feature = "strict")]
446 return _serde::__private::Err(
447 <__A::Error as _serde::de::Error>::duplicate_field(
448 "rotation1",
449 ),
450 );
451 }
452 m_rotation1 = _serde::__private::Some(
453 match __A::next_value::<Quaternion>(&mut __map) {
454 _serde::__private::Ok(__val) => __val,
455 _serde::__private::Err(__err) => {
456 return _serde::__private::Err(__err);
457 }
458 },
459 );
460 }
461 __Field::m_centerOfMassLocal => {
462 #[cfg(
463 any(feature = "strict", feature = "ignore_duplicates")
464 )]
465 if _serde::__private::Option::is_some(
466 &m_centerOfMassLocal,
467 ) {
468 #[cfg(feature = "ignore_duplicates")]
469 {
470 __A::skip_value(&mut __map)?;
471 continue;
472 }
473 #[cfg(feature = "strict")]
474 return _serde::__private::Err(
475 <__A::Error as _serde::de::Error>::duplicate_field(
476 "centerOfMassLocal",
477 ),
478 );
479 }
480 m_centerOfMassLocal = _serde::__private::Some(
481 match __A::next_value::<Vector4>(&mut __map) {
482 _serde::__private::Ok(__val) => __val,
483 _serde::__private::Err(__err) => {
484 return _serde::__private::Err(__err);
485 }
486 },
487 );
488 }
489 _ => __A::skip_value(&mut __map)?,
490 }
491 }
492 let m_centerOfMass0 = match m_centerOfMass0 {
493 _serde::__private::Some(__field) => __field,
494 _serde::__private::None => {
495 #[cfg(feature = "strict")]
496 return _serde::__private::Err(
497 <__A::Error as _serde::de::Error>::missing_field(
498 "centerOfMass0",
499 ),
500 );
501 #[cfg(not(feature = "strict"))] Default::default()
502 }
503 };
504 let m_centerOfMass1 = match m_centerOfMass1 {
505 _serde::__private::Some(__field) => __field,
506 _serde::__private::None => {
507 #[cfg(feature = "strict")]
508 return _serde::__private::Err(
509 <__A::Error as _serde::de::Error>::missing_field(
510 "centerOfMass1",
511 ),
512 );
513 #[cfg(not(feature = "strict"))] Default::default()
514 }
515 };
516 let m_rotation0 = match m_rotation0 {
517 _serde::__private::Some(__field) => __field,
518 _serde::__private::None => {
519 #[cfg(feature = "strict")]
520 return _serde::__private::Err(
521 <__A::Error as _serde::de::Error>::missing_field(
522 "rotation0",
523 ),
524 );
525 #[cfg(not(feature = "strict"))] Default::default()
526 }
527 };
528 let m_rotation1 = match m_rotation1 {
529 _serde::__private::Some(__field) => __field,
530 _serde::__private::None => {
531 #[cfg(feature = "strict")]
532 return _serde::__private::Err(
533 <__A::Error as _serde::de::Error>::missing_field(
534 "rotation1",
535 ),
536 );
537 #[cfg(not(feature = "strict"))] Default::default()
538 }
539 };
540 let m_centerOfMassLocal = match m_centerOfMassLocal {
541 _serde::__private::Some(__field) => __field,
542 _serde::__private::None => {
543 #[cfg(feature = "strict")]
544 return _serde::__private::Err(
545 <__A::Error as _serde::de::Error>::missing_field(
546 "centerOfMassLocal",
547 ),
548 );
549 #[cfg(not(feature = "strict"))] Default::default()
550 }
551 };
552 let __ptr = __A::class_ptr(&mut __map);
553 _serde::__private::Ok(hkSweptTransform {
554 __ptr,
555 m_centerOfMass0,
556 m_centerOfMass1,
557 m_rotation0,
558 m_rotation1,
559 m_centerOfMassLocal,
560 })
561 }
562 }
563 const FIELDS: &[&str] = &[
564 "centerOfMass0",
565 "centerOfMass1",
566 "rotation0",
567 "rotation1",
568 "centerOfMassLocal",
569 ];
570 _serde::Deserializer::deserialize_struct(
571 deserializer,
572 "hkSweptTransform",
573 FIELDS,
574 __hkSweptTransformVisitor {
575 marker: _serde::__private::PhantomData::<hkSweptTransform>,
576 lifetime: _serde::__private::PhantomData,
577 },
578 )
579 }
580 }
581};