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