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