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