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