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