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 hkpSimulation {
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(
35 feature = "json_schema",
36 schemars(rename = "determinismCheckFrameCounter")
37 )]
38 #[cfg_attr(feature = "serde", serde(rename = "determinismCheckFrameCounter"))]
39 pub m_determinismCheckFrameCounter: u32,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "world"))]
45 #[cfg_attr(feature = "serde", serde(rename = "world"))]
46 pub m_world: Pointer,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "lastProcessingStep"))]
52 #[cfg_attr(feature = "serde", serde(rename = "lastProcessingStep"))]
53 pub m_lastProcessingStep: LastProcessingStep,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "currentTime"))]
59 #[cfg_attr(feature = "serde", serde(rename = "currentTime"))]
60 pub m_currentTime: f32,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "currentPsiTime"))]
66 #[cfg_attr(feature = "serde", serde(rename = "currentPsiTime"))]
67 pub m_currentPsiTime: f32,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "physicsDeltaTime"))]
73 #[cfg_attr(feature = "serde", serde(rename = "physicsDeltaTime"))]
74 pub m_physicsDeltaTime: f32,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "simulateUntilTime"))]
80 #[cfg_attr(feature = "serde", serde(rename = "simulateUntilTime"))]
81 pub m_simulateUntilTime: f32,
82 #[cfg_attr(feature = "json_schema", schemars(rename = "frameMarkerPsiSnap"))]
87 #[cfg_attr(feature = "serde", serde(rename = "frameMarkerPsiSnap"))]
88 pub m_frameMarkerPsiSnap: f32,
89 #[cfg_attr(feature = "json_schema", schemars(rename = "previousStepResult"))]
94 #[cfg_attr(feature = "serde", serde(rename = "previousStepResult"))]
95 pub m_previousStepResult: u32,
96}
97const _: () = {
98 use havok_serde as _serde;
99 impl _serde::HavokClass for hkpSimulation {
100 #[inline]
101 fn name(&self) -> &'static str {
102 "hkpSimulation"
103 }
104 #[inline]
105 fn signature(&self) -> _serde::__private::Signature {
106 _serde::__private::Signature::new(0x97aba922)
107 }
108 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
109 fn deps_indexes(&self) -> Vec<usize> {
110 let mut v = Vec::new();
111 v.push(self.m_world.get());
112 v
113 }
114 }
115 impl _serde::Serialize for hkpSimulation {
116 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
117 where
118 S: _serde::ser::Serializer,
119 {
120 let class_meta = self
121 .__ptr
122 .map(|name| (name, _serde::__private::Signature::new(0x97aba922)));
123 let mut serializer = __serializer
124 .serialize_struct("hkpSimulation", class_meta, (44u64, 64u64))?;
125 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
126 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
127 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
128 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
129 serializer
130 .serialize_field(
131 "determinismCheckFrameCounter",
132 &self.m_determinismCheckFrameCounter,
133 )?;
134 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
135 serializer.serialize_field("world", &self.m_world)?;
136 serializer
137 .serialize_field("lastProcessingStep", &self.m_lastProcessingStep)?;
138 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
139 serializer.serialize_field("currentTime", &self.m_currentTime)?;
140 serializer.serialize_field("currentPsiTime", &self.m_currentPsiTime)?;
141 serializer.serialize_field("physicsDeltaTime", &self.m_physicsDeltaTime)?;
142 serializer.serialize_field("simulateUntilTime", &self.m_simulateUntilTime)?;
143 serializer
144 .serialize_field("frameMarkerPsiSnap", &self.m_frameMarkerPsiSnap)?;
145 serializer
146 .serialize_field("previousStepResult", &self.m_previousStepResult)?;
147 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
148 serializer.end()
149 }
150 }
151};
152#[doc(hidden)]
153#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
154const _: () = {
155 use havok_serde as _serde;
156 #[automatically_derived]
157 impl<'de> _serde::Deserialize<'de> for hkpSimulation {
158 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
159 where
160 __D: _serde::Deserializer<'de>,
161 {
162 #[allow(non_camel_case_types)]
163 enum __Field {
164 m_determinismCheckFrameCounter,
165 m_world,
166 m_lastProcessingStep,
167 m_currentTime,
168 m_currentPsiTime,
169 m_physicsDeltaTime,
170 m_simulateUntilTime,
171 m_frameMarkerPsiSnap,
172 m_previousStepResult,
173 __ignore,
174 }
175 struct __FieldVisitor;
176 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
177 type Value = __Field;
178 fn expecting(
179 &self,
180 __formatter: &mut core::fmt::Formatter,
181 ) -> core::fmt::Result {
182 core::fmt::Formatter::write_str(__formatter, "field identifier")
183 }
184 #[allow(clippy::match_single_binding)]
186 #[allow(clippy::reversed_empty_ranges)]
187 #[allow(clippy::single_match)]
188 fn visit_key<__E>(
189 self,
190 __value: &str,
191 ) -> core::result::Result<Self::Value, __E>
192 where
193 __E: _serde::de::Error,
194 {
195 match __value {
196 "determinismCheckFrameCounter" => {
197 Ok(__Field::m_determinismCheckFrameCounter)
198 }
199 "world" => Ok(__Field::m_world),
200 "lastProcessingStep" => Ok(__Field::m_lastProcessingStep),
201 "currentTime" => Ok(__Field::m_currentTime),
202 "currentPsiTime" => Ok(__Field::m_currentPsiTime),
203 "physicsDeltaTime" => Ok(__Field::m_physicsDeltaTime),
204 "simulateUntilTime" => Ok(__Field::m_simulateUntilTime),
205 "frameMarkerPsiSnap" => Ok(__Field::m_frameMarkerPsiSnap),
206 "previousStepResult" => Ok(__Field::m_previousStepResult),
207 _ => Ok(__Field::__ignore),
208 }
209 }
210 }
211 impl<'de> _serde::Deserialize<'de> for __Field {
212 #[inline]
213 fn deserialize<__D>(
214 __deserializer: __D,
215 ) -> core::result::Result<Self, __D::Error>
216 where
217 __D: _serde::Deserializer<'de>,
218 {
219 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
220 }
221 }
222 struct __hkpSimulationVisitor<'de> {
223 marker: _serde::__private::PhantomData<hkpSimulation>,
224 lifetime: _serde::__private::PhantomData<&'de ()>,
225 }
226 #[allow(clippy::match_single_binding)]
227 #[allow(clippy::reversed_empty_ranges)]
228 #[allow(clippy::single_match)]
229 impl<'de> _serde::de::Visitor<'de> for __hkpSimulationVisitor<'de> {
230 type Value = hkpSimulation;
231 fn expecting(
232 &self,
233 __formatter: &mut core::fmt::Formatter,
234 ) -> core::fmt::Result {
235 core::fmt::Formatter::write_str(__formatter, "struct hkpSimulation")
236 }
237 fn visit_struct_for_bytes<__A>(
238 self,
239 mut __map: __A,
240 ) -> _serde::__private::Result<Self::Value, __A::Error>
241 where
242 __A: _serde::de::MapAccess<'de>,
243 {
244 let __ptr = __A::class_ptr(&mut __map);
245 let parent = __A::parent_value(&mut __map)?;
246 let mut m_determinismCheckFrameCounter: _serde::__private::Option<
247 u32,
248 > = _serde::__private::None;
249 let mut m_world: _serde::__private::Option<Pointer> = _serde::__private::None;
250 let mut m_lastProcessingStep: _serde::__private::Option<
251 LastProcessingStep,
252 > = _serde::__private::None;
253 let mut m_currentTime: _serde::__private::Option<f32> = _serde::__private::None;
254 let mut m_currentPsiTime: _serde::__private::Option<f32> = _serde::__private::None;
255 let mut m_physicsDeltaTime: _serde::__private::Option<f32> = _serde::__private::None;
256 let mut m_simulateUntilTime: _serde::__private::Option<f32> = _serde::__private::None;
257 let mut m_frameMarkerPsiSnap: _serde::__private::Option<f32> = _serde::__private::None;
258 let mut m_previousStepResult: _serde::__private::Option<u32> = _serde::__private::None;
259 for i in 0..9usize {
260 match i {
261 0usize => {
262 if _serde::__private::Option::is_some(
263 &m_determinismCheckFrameCounter,
264 ) {
265 return _serde::__private::Err(
266 <__A::Error as _serde::de::Error>::duplicate_field(
267 "determinismCheckFrameCounter",
268 ),
269 );
270 }
271 m_determinismCheckFrameCounter = _serde::__private::Some(
272 match __A::next_value::<u32>(&mut __map) {
273 _serde::__private::Ok(__val) => __val,
274 _serde::__private::Err(__err) => {
275 return _serde::__private::Err(__err);
276 }
277 },
278 );
279 }
280 1usize => {
281 if _serde::__private::Option::is_some(&m_world) {
282 return _serde::__private::Err(
283 <__A::Error as _serde::de::Error>::duplicate_field("world"),
284 );
285 }
286 __A::pad(&mut __map, 0usize, 4usize)?;
287 m_world = _serde::__private::Some(
288 match __A::next_value::<Pointer>(&mut __map) {
289 _serde::__private::Ok(__val) => __val,
290 _serde::__private::Err(__err) => {
291 return _serde::__private::Err(__err);
292 }
293 },
294 );
295 }
296 2usize => {
297 if _serde::__private::Option::is_some(
298 &m_lastProcessingStep,
299 ) {
300 return _serde::__private::Err(
301 <__A::Error as _serde::de::Error>::duplicate_field(
302 "lastProcessingStep",
303 ),
304 );
305 }
306 m_lastProcessingStep = _serde::__private::Some(
307 match __A::next_value::<LastProcessingStep>(&mut __map) {
308 _serde::__private::Ok(__val) => __val,
309 _serde::__private::Err(__err) => {
310 return _serde::__private::Err(__err);
311 }
312 },
313 );
314 }
315 3usize => {
316 if _serde::__private::Option::is_some(&m_currentTime) {
317 return _serde::__private::Err(
318 <__A::Error as _serde::de::Error>::duplicate_field(
319 "currentTime",
320 ),
321 );
322 }
323 __A::pad(&mut __map, 3usize, 3usize)?;
324 m_currentTime = _serde::__private::Some(
325 match __A::next_value::<f32>(&mut __map) {
326 _serde::__private::Ok(__val) => __val,
327 _serde::__private::Err(__err) => {
328 return _serde::__private::Err(__err);
329 }
330 },
331 );
332 }
333 4usize => {
334 if _serde::__private::Option::is_some(&m_currentPsiTime) {
335 return _serde::__private::Err(
336 <__A::Error as _serde::de::Error>::duplicate_field(
337 "currentPsiTime",
338 ),
339 );
340 }
341 m_currentPsiTime = _serde::__private::Some(
342 match __A::next_value::<f32>(&mut __map) {
343 _serde::__private::Ok(__val) => __val,
344 _serde::__private::Err(__err) => {
345 return _serde::__private::Err(__err);
346 }
347 },
348 );
349 }
350 5usize => {
351 if _serde::__private::Option::is_some(&m_physicsDeltaTime) {
352 return _serde::__private::Err(
353 <__A::Error as _serde::de::Error>::duplicate_field(
354 "physicsDeltaTime",
355 ),
356 );
357 }
358 m_physicsDeltaTime = _serde::__private::Some(
359 match __A::next_value::<f32>(&mut __map) {
360 _serde::__private::Ok(__val) => __val,
361 _serde::__private::Err(__err) => {
362 return _serde::__private::Err(__err);
363 }
364 },
365 );
366 }
367 6usize => {
368 if _serde::__private::Option::is_some(
369 &m_simulateUntilTime,
370 ) {
371 return _serde::__private::Err(
372 <__A::Error as _serde::de::Error>::duplicate_field(
373 "simulateUntilTime",
374 ),
375 );
376 }
377 m_simulateUntilTime = _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 7usize => {
387 if _serde::__private::Option::is_some(
388 &m_frameMarkerPsiSnap,
389 ) {
390 return _serde::__private::Err(
391 <__A::Error as _serde::de::Error>::duplicate_field(
392 "frameMarkerPsiSnap",
393 ),
394 );
395 }
396 m_frameMarkerPsiSnap = _serde::__private::Some(
397 match __A::next_value::<f32>(&mut __map) {
398 _serde::__private::Ok(__val) => __val,
399 _serde::__private::Err(__err) => {
400 return _serde::__private::Err(__err);
401 }
402 },
403 );
404 }
405 8usize => {
406 if _serde::__private::Option::is_some(
407 &m_previousStepResult,
408 ) {
409 return _serde::__private::Err(
410 <__A::Error as _serde::de::Error>::duplicate_field(
411 "previousStepResult",
412 ),
413 );
414 }
415 m_previousStepResult = _serde::__private::Some(
416 match __A::next_value::<u32>(&mut __map) {
417 _serde::__private::Ok(__val) => __val,
418 _serde::__private::Err(__err) => {
419 return _serde::__private::Err(__err);
420 }
421 },
422 );
423 }
424 _ => {}
425 }
426 }
427 __A::pad(&mut __map, 0usize, 4usize)?;
428 let m_determinismCheckFrameCounter = match m_determinismCheckFrameCounter {
429 _serde::__private::Some(__field) => __field,
430 _serde::__private::None => {
431 return _serde::__private::Err(
432 <__A::Error as _serde::de::Error>::missing_field(
433 "determinismCheckFrameCounter",
434 ),
435 );
436 }
437 };
438 let m_world = match m_world {
439 _serde::__private::Some(__field) => __field,
440 _serde::__private::None => {
441 return _serde::__private::Err(
442 <__A::Error as _serde::de::Error>::missing_field("world"),
443 );
444 }
445 };
446 let m_lastProcessingStep = match m_lastProcessingStep {
447 _serde::__private::Some(__field) => __field,
448 _serde::__private::None => {
449 return _serde::__private::Err(
450 <__A::Error as _serde::de::Error>::missing_field(
451 "lastProcessingStep",
452 ),
453 );
454 }
455 };
456 let m_currentTime = match m_currentTime {
457 _serde::__private::Some(__field) => __field,
458 _serde::__private::None => {
459 return _serde::__private::Err(
460 <__A::Error as _serde::de::Error>::missing_field(
461 "currentTime",
462 ),
463 );
464 }
465 };
466 let m_currentPsiTime = match m_currentPsiTime {
467 _serde::__private::Some(__field) => __field,
468 _serde::__private::None => {
469 return _serde::__private::Err(
470 <__A::Error as _serde::de::Error>::missing_field(
471 "currentPsiTime",
472 ),
473 );
474 }
475 };
476 let m_physicsDeltaTime = match m_physicsDeltaTime {
477 _serde::__private::Some(__field) => __field,
478 _serde::__private::None => {
479 return _serde::__private::Err(
480 <__A::Error as _serde::de::Error>::missing_field(
481 "physicsDeltaTime",
482 ),
483 );
484 }
485 };
486 let m_simulateUntilTime = match m_simulateUntilTime {
487 _serde::__private::Some(__field) => __field,
488 _serde::__private::None => {
489 return _serde::__private::Err(
490 <__A::Error as _serde::de::Error>::missing_field(
491 "simulateUntilTime",
492 ),
493 );
494 }
495 };
496 let m_frameMarkerPsiSnap = match m_frameMarkerPsiSnap {
497 _serde::__private::Some(__field) => __field,
498 _serde::__private::None => {
499 return _serde::__private::Err(
500 <__A::Error as _serde::de::Error>::missing_field(
501 "frameMarkerPsiSnap",
502 ),
503 );
504 }
505 };
506 let m_previousStepResult = match m_previousStepResult {
507 _serde::__private::Some(__field) => __field,
508 _serde::__private::None => {
509 return _serde::__private::Err(
510 <__A::Error as _serde::de::Error>::missing_field(
511 "previousStepResult",
512 ),
513 );
514 }
515 };
516 _serde::__private::Ok(hkpSimulation {
517 __ptr,
518 parent,
519 m_determinismCheckFrameCounter,
520 m_world,
521 m_lastProcessingStep,
522 m_currentTime,
523 m_currentPsiTime,
524 m_physicsDeltaTime,
525 m_simulateUntilTime,
526 m_frameMarkerPsiSnap,
527 m_previousStepResult,
528 })
529 }
530 #[allow(clippy::manual_unwrap_or_default)]
531 fn visit_struct<__A>(
532 self,
533 mut __map: __A,
534 ) -> _serde::__private::Result<Self::Value, __A::Error>
535 where
536 __A: _serde::de::MapAccess<'de>,
537 {
538 let mut m_determinismCheckFrameCounter: _serde::__private::Option<
539 u32,
540 > = _serde::__private::None;
541 let mut m_world: _serde::__private::Option<Pointer> = _serde::__private::None;
542 let mut m_lastProcessingStep: _serde::__private::Option<
543 LastProcessingStep,
544 > = _serde::__private::None;
545 let mut m_currentTime: _serde::__private::Option<f32> = _serde::__private::None;
546 let mut m_currentPsiTime: _serde::__private::Option<f32> = _serde::__private::None;
547 let mut m_physicsDeltaTime: _serde::__private::Option<f32> = _serde::__private::None;
548 let mut m_simulateUntilTime: _serde::__private::Option<f32> = _serde::__private::None;
549 let mut m_frameMarkerPsiSnap: _serde::__private::Option<f32> = _serde::__private::None;
550 let mut m_previousStepResult: _serde::__private::Option<u32> = _serde::__private::None;
551 while let _serde::__private::Some(__key) = {
552 __A::next_key::<__Field>(&mut __map)?
553 } {
554 match __key {
555 __Field::m_determinismCheckFrameCounter => {
556 #[cfg(
557 any(feature = "strict", feature = "ignore_duplicates")
558 )]
559 if _serde::__private::Option::is_some(
560 &m_determinismCheckFrameCounter,
561 ) {
562 #[cfg(feature = "ignore_duplicates")]
563 {
564 __A::skip_value(&mut __map)?;
565 continue;
566 }
567 #[cfg(feature = "strict")]
568 return _serde::__private::Err(
569 <__A::Error as _serde::de::Error>::duplicate_field(
570 "determinismCheckFrameCounter",
571 ),
572 );
573 }
574 m_determinismCheckFrameCounter = _serde::__private::Some(
575 match __A::next_value::<u32>(&mut __map) {
576 _serde::__private::Ok(__val) => __val,
577 _serde::__private::Err(__err) => {
578 return _serde::__private::Err(__err);
579 }
580 },
581 );
582 }
583 __Field::m_world => {
584 #[cfg(
585 any(feature = "strict", feature = "ignore_duplicates")
586 )]
587 if _serde::__private::Option::is_some(&m_world) {
588 #[cfg(feature = "ignore_duplicates")]
589 {
590 __A::skip_value(&mut __map)?;
591 continue;
592 }
593 #[cfg(feature = "strict")]
594 return _serde::__private::Err(
595 <__A::Error as _serde::de::Error>::duplicate_field("world"),
596 );
597 }
598 m_world = _serde::__private::Some(
599 match __A::next_value::<Pointer>(&mut __map) {
600 _serde::__private::Ok(__val) => __val,
601 _serde::__private::Err(__err) => {
602 return _serde::__private::Err(__err);
603 }
604 },
605 );
606 }
607 __Field::m_lastProcessingStep => {
608 #[cfg(
609 any(feature = "strict", feature = "ignore_duplicates")
610 )]
611 if _serde::__private::Option::is_some(
612 &m_lastProcessingStep,
613 ) {
614 #[cfg(feature = "ignore_duplicates")]
615 {
616 __A::skip_value(&mut __map)?;
617 continue;
618 }
619 #[cfg(feature = "strict")]
620 return _serde::__private::Err(
621 <__A::Error as _serde::de::Error>::duplicate_field(
622 "lastProcessingStep",
623 ),
624 );
625 }
626 m_lastProcessingStep = _serde::__private::Some(
627 match __A::next_value::<LastProcessingStep>(&mut __map) {
628 _serde::__private::Ok(__val) => __val,
629 _serde::__private::Err(__err) => {
630 return _serde::__private::Err(__err);
631 }
632 },
633 );
634 }
635 __Field::m_currentTime => {
636 #[cfg(
637 any(feature = "strict", feature = "ignore_duplicates")
638 )]
639 if _serde::__private::Option::is_some(&m_currentTime) {
640 #[cfg(feature = "ignore_duplicates")]
641 {
642 __A::skip_value(&mut __map)?;
643 continue;
644 }
645 #[cfg(feature = "strict")]
646 return _serde::__private::Err(
647 <__A::Error as _serde::de::Error>::duplicate_field(
648 "currentTime",
649 ),
650 );
651 }
652 m_currentTime = _serde::__private::Some(
653 match __A::next_value::<f32>(&mut __map) {
654 _serde::__private::Ok(__val) => __val,
655 _serde::__private::Err(__err) => {
656 return _serde::__private::Err(__err);
657 }
658 },
659 );
660 }
661 __Field::m_currentPsiTime => {
662 #[cfg(
663 any(feature = "strict", feature = "ignore_duplicates")
664 )]
665 if _serde::__private::Option::is_some(&m_currentPsiTime) {
666 #[cfg(feature = "ignore_duplicates")]
667 {
668 __A::skip_value(&mut __map)?;
669 continue;
670 }
671 #[cfg(feature = "strict")]
672 return _serde::__private::Err(
673 <__A::Error as _serde::de::Error>::duplicate_field(
674 "currentPsiTime",
675 ),
676 );
677 }
678 m_currentPsiTime = _serde::__private::Some(
679 match __A::next_value::<f32>(&mut __map) {
680 _serde::__private::Ok(__val) => __val,
681 _serde::__private::Err(__err) => {
682 return _serde::__private::Err(__err);
683 }
684 },
685 );
686 }
687 __Field::m_physicsDeltaTime => {
688 #[cfg(
689 any(feature = "strict", feature = "ignore_duplicates")
690 )]
691 if _serde::__private::Option::is_some(&m_physicsDeltaTime) {
692 #[cfg(feature = "ignore_duplicates")]
693 {
694 __A::skip_value(&mut __map)?;
695 continue;
696 }
697 #[cfg(feature = "strict")]
698 return _serde::__private::Err(
699 <__A::Error as _serde::de::Error>::duplicate_field(
700 "physicsDeltaTime",
701 ),
702 );
703 }
704 m_physicsDeltaTime = _serde::__private::Some(
705 match __A::next_value::<f32>(&mut __map) {
706 _serde::__private::Ok(__val) => __val,
707 _serde::__private::Err(__err) => {
708 return _serde::__private::Err(__err);
709 }
710 },
711 );
712 }
713 __Field::m_simulateUntilTime => {
714 #[cfg(
715 any(feature = "strict", feature = "ignore_duplicates")
716 )]
717 if _serde::__private::Option::is_some(
718 &m_simulateUntilTime,
719 ) {
720 #[cfg(feature = "ignore_duplicates")]
721 {
722 __A::skip_value(&mut __map)?;
723 continue;
724 }
725 #[cfg(feature = "strict")]
726 return _serde::__private::Err(
727 <__A::Error as _serde::de::Error>::duplicate_field(
728 "simulateUntilTime",
729 ),
730 );
731 }
732 m_simulateUntilTime = _serde::__private::Some(
733 match __A::next_value::<f32>(&mut __map) {
734 _serde::__private::Ok(__val) => __val,
735 _serde::__private::Err(__err) => {
736 return _serde::__private::Err(__err);
737 }
738 },
739 );
740 }
741 __Field::m_frameMarkerPsiSnap => {
742 #[cfg(
743 any(feature = "strict", feature = "ignore_duplicates")
744 )]
745 if _serde::__private::Option::is_some(
746 &m_frameMarkerPsiSnap,
747 ) {
748 #[cfg(feature = "ignore_duplicates")]
749 {
750 __A::skip_value(&mut __map)?;
751 continue;
752 }
753 #[cfg(feature = "strict")]
754 return _serde::__private::Err(
755 <__A::Error as _serde::de::Error>::duplicate_field(
756 "frameMarkerPsiSnap",
757 ),
758 );
759 }
760 m_frameMarkerPsiSnap = _serde::__private::Some(
761 match __A::next_value::<f32>(&mut __map) {
762 _serde::__private::Ok(__val) => __val,
763 _serde::__private::Err(__err) => {
764 return _serde::__private::Err(__err);
765 }
766 },
767 );
768 }
769 __Field::m_previousStepResult => {
770 #[cfg(
771 any(feature = "strict", feature = "ignore_duplicates")
772 )]
773 if _serde::__private::Option::is_some(
774 &m_previousStepResult,
775 ) {
776 #[cfg(feature = "ignore_duplicates")]
777 {
778 __A::skip_value(&mut __map)?;
779 continue;
780 }
781 #[cfg(feature = "strict")]
782 return _serde::__private::Err(
783 <__A::Error as _serde::de::Error>::duplicate_field(
784 "previousStepResult",
785 ),
786 );
787 }
788 m_previousStepResult = _serde::__private::Some(
789 match __A::next_value::<u32>(&mut __map) {
790 _serde::__private::Ok(__val) => __val,
791 _serde::__private::Err(__err) => {
792 return _serde::__private::Err(__err);
793 }
794 },
795 );
796 }
797 _ => __A::skip_value(&mut __map)?,
798 }
799 }
800 let m_determinismCheckFrameCounter = match m_determinismCheckFrameCounter {
801 _serde::__private::Some(__field) => __field,
802 _serde::__private::None => {
803 #[cfg(feature = "strict")]
804 return _serde::__private::Err(
805 <__A::Error as _serde::de::Error>::missing_field(
806 "determinismCheckFrameCounter",
807 ),
808 );
809 #[cfg(not(feature = "strict"))] Default::default()
810 }
811 };
812 let m_world = match m_world {
813 _serde::__private::Some(__field) => __field,
814 _serde::__private::None => {
815 #[cfg(feature = "strict")]
816 return _serde::__private::Err(
817 <__A::Error as _serde::de::Error>::missing_field("world"),
818 );
819 #[cfg(not(feature = "strict"))] Default::default()
820 }
821 };
822 let m_lastProcessingStep = match m_lastProcessingStep {
823 _serde::__private::Some(__field) => __field,
824 _serde::__private::None => {
825 #[cfg(feature = "strict")]
826 return _serde::__private::Err(
827 <__A::Error as _serde::de::Error>::missing_field(
828 "lastProcessingStep",
829 ),
830 );
831 #[cfg(not(feature = "strict"))] Default::default()
832 }
833 };
834 let m_currentTime = match m_currentTime {
835 _serde::__private::Some(__field) => __field,
836 _serde::__private::None => {
837 #[cfg(feature = "strict")]
838 return _serde::__private::Err(
839 <__A::Error as _serde::de::Error>::missing_field(
840 "currentTime",
841 ),
842 );
843 #[cfg(not(feature = "strict"))] Default::default()
844 }
845 };
846 let m_currentPsiTime = match m_currentPsiTime {
847 _serde::__private::Some(__field) => __field,
848 _serde::__private::None => {
849 #[cfg(feature = "strict")]
850 return _serde::__private::Err(
851 <__A::Error as _serde::de::Error>::missing_field(
852 "currentPsiTime",
853 ),
854 );
855 #[cfg(not(feature = "strict"))] Default::default()
856 }
857 };
858 let m_physicsDeltaTime = match m_physicsDeltaTime {
859 _serde::__private::Some(__field) => __field,
860 _serde::__private::None => {
861 #[cfg(feature = "strict")]
862 return _serde::__private::Err(
863 <__A::Error as _serde::de::Error>::missing_field(
864 "physicsDeltaTime",
865 ),
866 );
867 #[cfg(not(feature = "strict"))] Default::default()
868 }
869 };
870 let m_simulateUntilTime = match m_simulateUntilTime {
871 _serde::__private::Some(__field) => __field,
872 _serde::__private::None => {
873 #[cfg(feature = "strict")]
874 return _serde::__private::Err(
875 <__A::Error as _serde::de::Error>::missing_field(
876 "simulateUntilTime",
877 ),
878 );
879 #[cfg(not(feature = "strict"))] Default::default()
880 }
881 };
882 let m_frameMarkerPsiSnap = match m_frameMarkerPsiSnap {
883 _serde::__private::Some(__field) => __field,
884 _serde::__private::None => {
885 #[cfg(feature = "strict")]
886 return _serde::__private::Err(
887 <__A::Error as _serde::de::Error>::missing_field(
888 "frameMarkerPsiSnap",
889 ),
890 );
891 #[cfg(not(feature = "strict"))] Default::default()
892 }
893 };
894 let m_previousStepResult = match m_previousStepResult {
895 _serde::__private::Some(__field) => __field,
896 _serde::__private::None => {
897 #[cfg(feature = "strict")]
898 return _serde::__private::Err(
899 <__A::Error as _serde::de::Error>::missing_field(
900 "previousStepResult",
901 ),
902 );
903 #[cfg(not(feature = "strict"))] Default::default()
904 }
905 };
906 let __ptr = None;
907 let parent = hkBaseObject { __ptr };
908 let parent = hkReferencedObject {
909 __ptr,
910 parent,
911 ..Default::default()
912 };
913 let __ptr = __A::class_ptr(&mut __map);
914 _serde::__private::Ok(hkpSimulation {
915 __ptr,
916 parent,
917 m_determinismCheckFrameCounter,
918 m_world,
919 m_lastProcessingStep,
920 m_currentTime,
921 m_currentPsiTime,
922 m_physicsDeltaTime,
923 m_simulateUntilTime,
924 m_frameMarkerPsiSnap,
925 m_previousStepResult,
926 })
927 }
928 }
929 const FIELDS: &[&str] = &[
930 "determinismCheckFrameCounter",
931 "world",
932 "lastProcessingStep",
933 "currentTime",
934 "currentPsiTime",
935 "physicsDeltaTime",
936 "simulateUntilTime",
937 "frameMarkerPsiSnap",
938 "previousStepResult",
939 ];
940 _serde::Deserializer::deserialize_struct(
941 deserializer,
942 "hkpSimulation",
943 FIELDS,
944 __hkpSimulationVisitor {
945 marker: _serde::__private::PhantomData::<hkpSimulation>,
946 lifetime: _serde::__private::PhantomData,
947 },
948 )
949 }
950 }
951};
952#[allow(non_upper_case_globals, non_snake_case)]
955#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
956#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
957#[derive(
958 Debug,
959 Clone,
960 Default,
961 PartialEq,
962 Eq,
963 PartialOrd,
964 Ord,
965 num_derive::ToPrimitive,
966 num_derive::FromPrimitive,
967)]
968pub enum LastProcessingStep {
969 #[default]
970 INTEGRATE = 0isize,
971 COLLIDE = 1isize,
972}
973const _: () = {
974 use havok_serde as __serde;
975 impl __serde::Serialize for LastProcessingStep {
976 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
977 where
978 S: __serde::ser::Serializer,
979 {
980 let mut __serializer = __serializer.serialize_enum_flags()?;
981 match self {
982 Self::INTEGRATE => __serializer.serialize_field("INTEGRATE", &0u64),
983 Self::COLLIDE => __serializer.serialize_field("COLLIDE", &1u64),
984 }?;
985 use num_traits::ToPrimitive as _;
986 let num = self
987 .to_u8()
988 .ok_or(S::Error::custom("Failed enum LastProcessingStep to_u8"))?;
989 __serializer.serialize_bits(&num)?;
990 __serializer.end()
991 }
992 }
993};
994#[doc(hidden)]
995#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
996const _: () = {
997 #[allow(unused_extern_crates, clippy::useless_attribute)]
998 extern crate havok_serde as _serde;
999 #[automatically_derived]
1000 impl<'de> _serde::Deserialize<'de> for LastProcessingStep {
1001 fn deserialize<__D>(
1002 __deserializer: __D,
1003 ) -> _serde::__private::Result<Self, __D::Error>
1004 where
1005 __D: _serde::Deserializer<'de>,
1006 {
1007 #[allow(non_camel_case_types)]
1008 #[doc(hidden)]
1009 enum __Field {
1010 __field0,
1011 __field1,
1012 }
1013 #[doc(hidden)]
1014 struct __FieldVisitor;
1015 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
1016 type Value = __Field;
1017 fn expecting(
1018 &self,
1019 __formatter: &mut _serde::__private::Formatter,
1020 ) -> _serde::__private::fmt::Result {
1021 _serde::__private::Formatter::write_str(
1022 __formatter,
1023 "variant identifier",
1024 )
1025 }
1026 fn visit_uint8<__E>(
1027 self,
1028 __value: u8,
1029 ) -> _serde::__private::Result<Self::Value, __E>
1030 where
1031 __E: _serde::de::Error,
1032 {
1033 match __value {
1034 0u8 => _serde::__private::Ok(__Field::__field0),
1035 1u8 => _serde::__private::Ok(__Field::__field1),
1036 _ => {
1037 _serde::__private::Err(
1038 _serde::de::Error::invalid_value(
1039 _serde::de::Unexpected::Uint8(__value),
1040 &"value(u8) of variant is one of 0, 1",
1041 ),
1042 )
1043 }
1044 }
1045 }
1046 fn visit_stringptr<__E>(
1047 self,
1048 __value: StringPtr<'de>,
1049 ) -> _serde::__private::Result<Self::Value, __E>
1050 where
1051 __E: _serde::de::Error,
1052 {
1053 if let Some(__value) = __value.into_inner() {
1054 match __value.as_ref() {
1055 v if v == "0" || v.eq_ignore_ascii_case("INTEGRATE") => {
1056 _serde::__private::Ok(__Field::__field0)
1057 }
1058 v if v == "1" || v.eq_ignore_ascii_case("COLLIDE") => {
1059 _serde::__private::Ok(__Field::__field1)
1060 }
1061 _ => {
1062 _serde::__private::Err(
1063 _serde::de::Error::unknown_variant(&__value, VARIANTS),
1064 )
1065 }
1066 }
1067 } else {
1068 _serde::__private::Err(
1069 _serde::de::Error::unknown_variant("None", VARIANTS),
1070 )
1071 }
1072 }
1073 }
1074 impl<'de> _serde::Deserialize<'de> for __Field {
1075 #[inline]
1076 fn deserialize<__D>(
1077 __deserializer: __D,
1078 ) -> _serde::__private::Result<Self, __D::Error>
1079 where
1080 __D: _serde::Deserializer<'de>,
1081 {
1082 _serde::Deserializer::deserialize_identifier(
1083 __deserializer,
1084 _serde::de::ReadEnumSize::Uint8,
1085 __FieldVisitor,
1086 )
1087 }
1088 }
1089 #[doc(hidden)]
1090 struct __Visitor<'de> {
1091 marker: _serde::__private::PhantomData<LastProcessingStep>,
1092 lifetime: _serde::__private::PhantomData<&'de ()>,
1093 }
1094 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1095 type Value = LastProcessingStep;
1096 fn expecting(
1097 &self,
1098 __formatter: &mut _serde::__private::Formatter,
1099 ) -> _serde::__private::fmt::Result {
1100 _serde::__private::Formatter::write_str(
1101 __formatter,
1102 "enum LastProcessingStep",
1103 )
1104 }
1105 fn visit_enum<__A>(
1106 self,
1107 __data: __A,
1108 ) -> _serde::__private::Result<Self::Value, __A::Error>
1109 where
1110 __A: _serde::de::EnumAccess<'de>,
1111 {
1112 match _serde::de::EnumAccess::variant(__data)? {
1113 (__Field::__field0, __variant) => {
1114 _serde::de::VariantAccess::unit_variant(__variant)?;
1115 _serde::__private::Ok(LastProcessingStep::INTEGRATE)
1116 }
1117 (__Field::__field1, __variant) => {
1118 _serde::de::VariantAccess::unit_variant(__variant)?;
1119 _serde::__private::Ok(LastProcessingStep::COLLIDE)
1120 }
1121 }
1122 }
1123 }
1124 #[doc(hidden)]
1125 const VARIANTS: &'static [&'static str] = &["INTEGRATE", "COLLIDE"];
1126 _serde::Deserializer::deserialize_enum(
1127 __deserializer,
1128 "LastProcessingStep",
1129 VARIANTS,
1130 __Visitor {
1131 marker: _serde::__private::PhantomData::<LastProcessingStep>,
1132 lifetime: _serde::__private::PhantomData,
1133 },
1134 )
1135 }
1136 }
1137};