havok_classes/generated/
hkHalf8_.rs1use 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 hkHalf8 {
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 = "quad"))]
32 #[cfg_attr(feature = "serde", serde(rename = "quad"))]
33 pub m_quad: [f16; 8usize],
34}
35const _: () = {
36 use havok_serde as _serde;
37 impl _serde::HavokClass for hkHalf8 {
38 #[inline]
39 fn name(&self) -> &'static str {
40 "hkHalf8"
41 }
42 #[inline]
43 fn signature(&self) -> _serde::__private::Signature {
44 _serde::__private::Signature::new(0x7684dc80)
45 }
46 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
47 fn deps_indexes(&self) -> Vec<usize> {
48 let mut v = Vec::new();
49 v
50 }
51 }
52 impl _serde::Serialize for hkHalf8 {
53 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
54 where
55 S: _serde::ser::Serializer,
56 {
57 let class_meta = self
58 .__ptr
59 .map(|name| (name, _serde::__private::Signature::new(0x7684dc80)));
60 let mut serializer = __serializer
61 .serialize_struct("hkHalf8", class_meta, (16u64, 16u64))?;
62 serializer
63 .serialize_fixed_array_field(
64 "quad",
65 self.m_quad.as_slice(),
66 TypeSize::NonPtr,
67 )?;
68 serializer.end()
69 }
70 }
71};
72#[doc(hidden)]
73#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
74const _: () = {
75 use havok_serde as _serde;
76 #[automatically_derived]
77 impl<'de> _serde::Deserialize<'de> for hkHalf8 {
78 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
79 where
80 __D: _serde::Deserializer<'de>,
81 {
82 #[allow(non_camel_case_types)]
83 enum __Field {
84 m_quad,
85 __ignore,
86 }
87 struct __FieldVisitor;
88 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
89 type Value = __Field;
90 fn expecting(
91 &self,
92 __formatter: &mut core::fmt::Formatter,
93 ) -> core::fmt::Result {
94 core::fmt::Formatter::write_str(__formatter, "field identifier")
95 }
96 #[allow(clippy::match_single_binding)]
98 #[allow(clippy::reversed_empty_ranges)]
99 #[allow(clippy::single_match)]
100 fn visit_key<__E>(
101 self,
102 __value: &str,
103 ) -> core::result::Result<Self::Value, __E>
104 where
105 __E: _serde::de::Error,
106 {
107 match __value {
108 "quad" => Ok(__Field::m_quad),
109 _ => Ok(__Field::__ignore),
110 }
111 }
112 }
113 impl<'de> _serde::Deserialize<'de> for __Field {
114 #[inline]
115 fn deserialize<__D>(
116 __deserializer: __D,
117 ) -> core::result::Result<Self, __D::Error>
118 where
119 __D: _serde::Deserializer<'de>,
120 {
121 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
122 }
123 }
124 struct __hkHalf8Visitor<'de> {
125 marker: _serde::__private::PhantomData<hkHalf8>,
126 lifetime: _serde::__private::PhantomData<&'de ()>,
127 }
128 #[allow(clippy::match_single_binding)]
129 #[allow(clippy::reversed_empty_ranges)]
130 #[allow(clippy::single_match)]
131 impl<'de> _serde::de::Visitor<'de> for __hkHalf8Visitor<'de> {
132 type Value = hkHalf8;
133 fn expecting(
134 &self,
135 __formatter: &mut core::fmt::Formatter,
136 ) -> core::fmt::Result {
137 core::fmt::Formatter::write_str(__formatter, "struct hkHalf8")
138 }
139 fn visit_struct_for_bytes<__A>(
140 self,
141 mut __map: __A,
142 ) -> _serde::__private::Result<Self::Value, __A::Error>
143 where
144 __A: _serde::de::MapAccess<'de>,
145 {
146 let __ptr = __A::class_ptr(&mut __map);
147 let mut m_quad: _serde::__private::Option<[f16; 8usize]> = _serde::__private::None;
148 for i in 0..1usize {
149 match i {
150 0usize => {
151 if _serde::__private::Option::is_some(&m_quad) {
152 return _serde::__private::Err(
153 <__A::Error as _serde::de::Error>::duplicate_field("quad"),
154 );
155 }
156 m_quad = _serde::__private::Some(
157 match __A::next_value::<[f16; 8usize]>(&mut __map) {
158 _serde::__private::Ok(__val) => __val,
159 _serde::__private::Err(__err) => {
160 return _serde::__private::Err(__err);
161 }
162 },
163 );
164 }
165 _ => {}
166 }
167 }
168 let m_quad = match m_quad {
169 _serde::__private::Some(__field) => __field,
170 _serde::__private::None => {
171 return _serde::__private::Err(
172 <__A::Error as _serde::de::Error>::missing_field("quad"),
173 );
174 }
175 };
176 _serde::__private::Ok(hkHalf8 { __ptr, m_quad })
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_quad: _serde::__private::Option<[f16; 8usize]> = _serde::__private::None;
187 while let _serde::__private::Some(__key) = {
188 __A::next_key::<__Field>(&mut __map)?
189 } {
190 match __key {
191 __Field::m_quad => {
192 #[cfg(
193 any(feature = "strict", feature = "ignore_duplicates")
194 )]
195 if _serde::__private::Option::is_some(&m_quad) {
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("quad"),
204 );
205 }
206 m_quad = _serde::__private::Some(
207 match __A::next_value::<[f16; 8usize]>(&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_quad = match m_quad {
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("quad"),
224 );
225 #[cfg(not(feature = "strict"))] Default::default()
226 }
227 };
228 let __ptr = __A::class_ptr(&mut __map);
229 _serde::__private::Ok(hkHalf8 { __ptr, m_quad })
230 }
231 }
232 const FIELDS: &[&str] = &["quad"];
233 _serde::Deserializer::deserialize_struct(
234 deserializer,
235 "hkHalf8",
236 FIELDS,
237 __hkHalf8Visitor {
238 marker: _serde::__private::PhantomData::<hkHalf8>,
239 lifetime: _serde::__private::PhantomData,
240 },
241 )
242 }
243 }
244};