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