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