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 hkxAnimatedFloat {
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 = "floats"))]
35 #[cfg_attr(feature = "serde", serde(rename = "floats"))]
36 pub m_floats: Vec<f32>,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "hint"))]
42 #[cfg_attr(feature = "serde", serde(rename = "hint"))]
43 pub m_hint: Hint,
44}
45const _: () = {
46 use havok_serde as _serde;
47 impl _serde::HavokClass for hkxAnimatedFloat {
48 #[inline]
49 fn name(&self) -> &'static str {
50 "hkxAnimatedFloat"
51 }
52 #[inline]
53 fn signature(&self) -> _serde::__private::Signature {
54 _serde::__private::Signature::new(0xce8b2fbd)
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 hkxAnimatedFloat {
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(0xce8b2fbd)));
70 let mut serializer = __serializer
71 .serialize_struct("hkxAnimatedFloat", class_meta, (24u64, 40u64))?;
72 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
73 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
74 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
75 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
76 serializer
77 .serialize_array_field("floats", &self.m_floats, TypeSize::NonPtr)?;
78 serializer.serialize_field("hint", &self.m_hint)?;
79 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
80 serializer.end()
81 }
82 }
83};
84#[doc(hidden)]
85#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
86const _: () = {
87 use havok_serde as _serde;
88 #[automatically_derived]
89 impl<'de> _serde::Deserialize<'de> for hkxAnimatedFloat {
90 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
91 where
92 __D: _serde::Deserializer<'de>,
93 {
94 #[allow(non_camel_case_types)]
95 enum __Field {
96 m_floats,
97 m_hint,
98 __ignore,
99 }
100 struct __FieldVisitor;
101 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
102 type Value = __Field;
103 fn expecting(
104 &self,
105 __formatter: &mut core::fmt::Formatter,
106 ) -> core::fmt::Result {
107 core::fmt::Formatter::write_str(__formatter, "field identifier")
108 }
109 #[allow(clippy::match_single_binding)]
111 #[allow(clippy::reversed_empty_ranges)]
112 #[allow(clippy::single_match)]
113 fn visit_key<__E>(
114 self,
115 __value: &str,
116 ) -> core::result::Result<Self::Value, __E>
117 where
118 __E: _serde::de::Error,
119 {
120 match __value {
121 "floats" => Ok(__Field::m_floats),
122 "hint" => Ok(__Field::m_hint),
123 _ => Ok(__Field::__ignore),
124 }
125 }
126 }
127 impl<'de> _serde::Deserialize<'de> for __Field {
128 #[inline]
129 fn deserialize<__D>(
130 __deserializer: __D,
131 ) -> core::result::Result<Self, __D::Error>
132 where
133 __D: _serde::Deserializer<'de>,
134 {
135 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
136 }
137 }
138 struct __hkxAnimatedFloatVisitor<'de> {
139 marker: _serde::__private::PhantomData<hkxAnimatedFloat>,
140 lifetime: _serde::__private::PhantomData<&'de ()>,
141 }
142 #[allow(clippy::match_single_binding)]
143 #[allow(clippy::reversed_empty_ranges)]
144 #[allow(clippy::single_match)]
145 impl<'de> _serde::de::Visitor<'de> for __hkxAnimatedFloatVisitor<'de> {
146 type Value = hkxAnimatedFloat;
147 fn expecting(
148 &self,
149 __formatter: &mut core::fmt::Formatter,
150 ) -> core::fmt::Result {
151 core::fmt::Formatter::write_str(
152 __formatter,
153 "struct hkxAnimatedFloat",
154 )
155 }
156 fn visit_struct_for_bytes<__A>(
157 self,
158 mut __map: __A,
159 ) -> _serde::__private::Result<Self::Value, __A::Error>
160 where
161 __A: _serde::de::MapAccess<'de>,
162 {
163 let __ptr = __A::class_ptr(&mut __map);
164 let parent = __A::parent_value(&mut __map)?;
165 let mut m_floats: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
166 let mut m_hint: _serde::__private::Option<Hint> = _serde::__private::None;
167 for i in 0..2usize {
168 match i {
169 0usize => {
170 if _serde::__private::Option::is_some(&m_floats) {
171 return _serde::__private::Err(
172 <__A::Error as _serde::de::Error>::duplicate_field("floats"),
173 );
174 }
175 m_floats = _serde::__private::Some(
176 match __A::next_value::<Vec<f32>>(&mut __map) {
177 _serde::__private::Ok(__val) => __val,
178 _serde::__private::Err(__err) => {
179 return _serde::__private::Err(__err);
180 }
181 },
182 );
183 }
184 1usize => {
185 if _serde::__private::Option::is_some(&m_hint) {
186 return _serde::__private::Err(
187 <__A::Error as _serde::de::Error>::duplicate_field("hint"),
188 );
189 }
190 m_hint = _serde::__private::Some(
191 match __A::next_value::<Hint>(&mut __map) {
192 _serde::__private::Ok(__val) => __val,
193 _serde::__private::Err(__err) => {
194 return _serde::__private::Err(__err);
195 }
196 },
197 );
198 }
199 _ => {}
200 }
201 }
202 __A::pad(&mut __map, 3usize, 7usize)?;
203 let m_floats = match m_floats {
204 _serde::__private::Some(__field) => __field,
205 _serde::__private::None => {
206 return _serde::__private::Err(
207 <__A::Error as _serde::de::Error>::missing_field("floats"),
208 );
209 }
210 };
211 let m_hint = match m_hint {
212 _serde::__private::Some(__field) => __field,
213 _serde::__private::None => {
214 return _serde::__private::Err(
215 <__A::Error as _serde::de::Error>::missing_field("hint"),
216 );
217 }
218 };
219 _serde::__private::Ok(hkxAnimatedFloat {
220 __ptr,
221 parent,
222 m_floats,
223 m_hint,
224 })
225 }
226 #[allow(clippy::manual_unwrap_or_default)]
227 fn visit_struct<__A>(
228 self,
229 mut __map: __A,
230 ) -> _serde::__private::Result<Self::Value, __A::Error>
231 where
232 __A: _serde::de::MapAccess<'de>,
233 {
234 let mut m_floats: _serde::__private::Option<Vec<f32>> = _serde::__private::None;
235 let mut m_hint: _serde::__private::Option<Hint> = _serde::__private::None;
236 while let _serde::__private::Some(__key) = {
237 __A::next_key::<__Field>(&mut __map)?
238 } {
239 match __key {
240 __Field::m_floats => {
241 #[cfg(
242 any(feature = "strict", feature = "ignore_duplicates")
243 )]
244 if _serde::__private::Option::is_some(&m_floats) {
245 #[cfg(feature = "ignore_duplicates")]
246 {
247 __A::skip_value(&mut __map)?;
248 continue;
249 }
250 #[cfg(feature = "strict")]
251 return _serde::__private::Err(
252 <__A::Error as _serde::de::Error>::duplicate_field("floats"),
253 );
254 }
255 m_floats = _serde::__private::Some(
256 match __A::next_value::<Vec<f32>>(&mut __map) {
257 _serde::__private::Ok(__val) => __val,
258 _serde::__private::Err(__err) => {
259 return _serde::__private::Err(__err);
260 }
261 },
262 );
263 }
264 __Field::m_hint => {
265 #[cfg(
266 any(feature = "strict", feature = "ignore_duplicates")
267 )]
268 if _serde::__private::Option::is_some(&m_hint) {
269 #[cfg(feature = "ignore_duplicates")]
270 {
271 __A::skip_value(&mut __map)?;
272 continue;
273 }
274 #[cfg(feature = "strict")]
275 return _serde::__private::Err(
276 <__A::Error as _serde::de::Error>::duplicate_field("hint"),
277 );
278 }
279 m_hint = _serde::__private::Some(
280 match __A::next_value::<Hint>(&mut __map) {
281 _serde::__private::Ok(__val) => __val,
282 _serde::__private::Err(__err) => {
283 return _serde::__private::Err(__err);
284 }
285 },
286 );
287 }
288 _ => __A::skip_value(&mut __map)?,
289 }
290 }
291 let m_floats = match m_floats {
292 _serde::__private::Some(__field) => __field,
293 _serde::__private::None => {
294 #[cfg(feature = "strict")]
295 return _serde::__private::Err(
296 <__A::Error as _serde::de::Error>::missing_field("floats"),
297 );
298 #[cfg(not(feature = "strict"))] Default::default()
299 }
300 };
301 let m_hint = match m_hint {
302 _serde::__private::Some(__field) => __field,
303 _serde::__private::None => {
304 #[cfg(feature = "strict")]
305 return _serde::__private::Err(
306 <__A::Error as _serde::de::Error>::missing_field("hint"),
307 );
308 #[cfg(not(feature = "strict"))] Default::default()
309 }
310 };
311 let __ptr = None;
312 let parent = hkBaseObject { __ptr };
313 let parent = hkReferencedObject {
314 __ptr,
315 parent,
316 ..Default::default()
317 };
318 let __ptr = __A::class_ptr(&mut __map);
319 _serde::__private::Ok(hkxAnimatedFloat {
320 __ptr,
321 parent,
322 m_floats,
323 m_hint,
324 })
325 }
326 }
327 const FIELDS: &[&str] = &["floats", "hint"];
328 _serde::Deserializer::deserialize_struct(
329 deserializer,
330 "hkxAnimatedFloat",
331 FIELDS,
332 __hkxAnimatedFloatVisitor {
333 marker: _serde::__private::PhantomData::<hkxAnimatedFloat>,
334 lifetime: _serde::__private::PhantomData,
335 },
336 )
337 }
338 }
339};