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