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