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 hkxAnimatedQuaternion {
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 = "quaternions"))]
35 #[cfg_attr(feature = "serde", serde(rename = "quaternions"))]
36 pub m_quaternions: Vec<Quaternion>,
37}
38const _: () = {
39 use havok_serde as _serde;
40 impl _serde::HavokClass for hkxAnimatedQuaternion {
41 #[inline]
42 fn name(&self) -> &'static str {
43 "hkxAnimatedQuaternion"
44 }
45 #[inline]
46 fn signature(&self) -> _serde::__private::Signature {
47 _serde::__private::Signature::new(0xb4f01baa)
48 }
49 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
50 fn deps_indexes(&self) -> Vec<usize> {
51 let mut v = Vec::new();
52 v
53 }
54 }
55 impl _serde::Serialize for hkxAnimatedQuaternion {
56 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
57 where
58 S: _serde::ser::Serializer,
59 {
60 let class_meta = self
61 .__ptr
62 .map(|name| (name, _serde::__private::Signature::new(0xb4f01baa)));
63 let mut serializer = __serializer
64 .serialize_struct("hkxAnimatedQuaternion", class_meta, (20u64, 32u64))?;
65 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
66 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
67 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
68 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
69 serializer
70 .serialize_array_field(
71 "quaternions",
72 &self.m_quaternions,
73 TypeSize::NonPtr,
74 )?;
75 serializer.end()
76 }
77 }
78};
79#[doc(hidden)]
80#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
81const _: () = {
82 use havok_serde as _serde;
83 #[automatically_derived]
84 impl<'de> _serde::Deserialize<'de> for hkxAnimatedQuaternion {
85 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
86 where
87 __D: _serde::Deserializer<'de>,
88 {
89 #[allow(non_camel_case_types)]
90 enum __Field {
91 m_quaternions,
92 __ignore,
93 }
94 struct __FieldVisitor;
95 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
96 type Value = __Field;
97 fn expecting(
98 &self,
99 __formatter: &mut core::fmt::Formatter,
100 ) -> core::fmt::Result {
101 core::fmt::Formatter::write_str(__formatter, "field identifier")
102 }
103 #[allow(clippy::match_single_binding)]
105 #[allow(clippy::reversed_empty_ranges)]
106 #[allow(clippy::single_match)]
107 fn visit_key<__E>(
108 self,
109 __value: &str,
110 ) -> core::result::Result<Self::Value, __E>
111 where
112 __E: _serde::de::Error,
113 {
114 match __value {
115 "quaternions" => Ok(__Field::m_quaternions),
116 _ => Ok(__Field::__ignore),
117 }
118 }
119 }
120 impl<'de> _serde::Deserialize<'de> for __Field {
121 #[inline]
122 fn deserialize<__D>(
123 __deserializer: __D,
124 ) -> core::result::Result<Self, __D::Error>
125 where
126 __D: _serde::Deserializer<'de>,
127 {
128 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
129 }
130 }
131 struct __hkxAnimatedQuaternionVisitor<'de> {
132 marker: _serde::__private::PhantomData<hkxAnimatedQuaternion>,
133 lifetime: _serde::__private::PhantomData<&'de ()>,
134 }
135 #[allow(clippy::match_single_binding)]
136 #[allow(clippy::reversed_empty_ranges)]
137 #[allow(clippy::single_match)]
138 impl<'de> _serde::de::Visitor<'de> for __hkxAnimatedQuaternionVisitor<'de> {
139 type Value = hkxAnimatedQuaternion;
140 fn expecting(
141 &self,
142 __formatter: &mut core::fmt::Formatter,
143 ) -> core::fmt::Result {
144 core::fmt::Formatter::write_str(
145 __formatter,
146 "struct hkxAnimatedQuaternion",
147 )
148 }
149 fn visit_struct_for_bytes<__A>(
150 self,
151 mut __map: __A,
152 ) -> _serde::__private::Result<Self::Value, __A::Error>
153 where
154 __A: _serde::de::MapAccess<'de>,
155 {
156 let __ptr = __A::class_ptr(&mut __map);
157 let parent = __A::parent_value(&mut __map)?;
158 let mut m_quaternions: _serde::__private::Option<Vec<Quaternion>> = _serde::__private::None;
159 for i in 0..1usize {
160 match i {
161 0usize => {
162 if _serde::__private::Option::is_some(&m_quaternions) {
163 return _serde::__private::Err(
164 <__A::Error as _serde::de::Error>::duplicate_field(
165 "quaternions",
166 ),
167 );
168 }
169 m_quaternions = _serde::__private::Some(
170 match __A::next_value::<Vec<Quaternion>>(&mut __map) {
171 _serde::__private::Ok(__val) => __val,
172 _serde::__private::Err(__err) => {
173 return _serde::__private::Err(__err);
174 }
175 },
176 );
177 }
178 _ => {}
179 }
180 }
181 let m_quaternions = match m_quaternions {
182 _serde::__private::Some(__field) => __field,
183 _serde::__private::None => {
184 return _serde::__private::Err(
185 <__A::Error as _serde::de::Error>::missing_field(
186 "quaternions",
187 ),
188 );
189 }
190 };
191 _serde::__private::Ok(hkxAnimatedQuaternion {
192 __ptr,
193 parent,
194 m_quaternions,
195 })
196 }
197 #[allow(clippy::manual_unwrap_or_default)]
198 fn visit_struct<__A>(
199 self,
200 mut __map: __A,
201 ) -> _serde::__private::Result<Self::Value, __A::Error>
202 where
203 __A: _serde::de::MapAccess<'de>,
204 {
205 let mut m_quaternions: _serde::__private::Option<Vec<Quaternion>> = _serde::__private::None;
206 while let _serde::__private::Some(__key) = {
207 __A::next_key::<__Field>(&mut __map)?
208 } {
209 match __key {
210 __Field::m_quaternions => {
211 #[cfg(
212 any(feature = "strict", feature = "ignore_duplicates")
213 )]
214 if _serde::__private::Option::is_some(&m_quaternions) {
215 #[cfg(feature = "ignore_duplicates")]
216 {
217 __A::skip_value(&mut __map)?;
218 continue;
219 }
220 #[cfg(feature = "strict")]
221 return _serde::__private::Err(
222 <__A::Error as _serde::de::Error>::duplicate_field(
223 "quaternions",
224 ),
225 );
226 }
227 m_quaternions = _serde::__private::Some(
228 match __A::next_value::<Vec<Quaternion>>(&mut __map) {
229 _serde::__private::Ok(__val) => __val,
230 _serde::__private::Err(__err) => {
231 return _serde::__private::Err(__err);
232 }
233 },
234 );
235 }
236 _ => __A::skip_value(&mut __map)?,
237 }
238 }
239 let m_quaternions = match m_quaternions {
240 _serde::__private::Some(__field) => __field,
241 _serde::__private::None => {
242 #[cfg(feature = "strict")]
243 return _serde::__private::Err(
244 <__A::Error as _serde::de::Error>::missing_field(
245 "quaternions",
246 ),
247 );
248 #[cfg(not(feature = "strict"))] Default::default()
249 }
250 };
251 let __ptr = None;
252 let parent = hkBaseObject { __ptr };
253 let parent = hkReferencedObject {
254 __ptr,
255 parent,
256 ..Default::default()
257 };
258 let __ptr = __A::class_ptr(&mut __map);
259 _serde::__private::Ok(hkxAnimatedQuaternion {
260 __ptr,
261 parent,
262 m_quaternions,
263 })
264 }
265 }
266 const FIELDS: &[&str] = &["quaternions"];
267 _serde::Deserializer::deserialize_struct(
268 deserializer,
269 "hkxAnimatedQuaternion",
270 FIELDS,
271 __hkxAnimatedQuaternionVisitor {
272 marker: _serde::__private::PhantomData::<hkxAnimatedQuaternion>,
273 lifetime: _serde::__private::PhantomData,
274 },
275 )
276 }
277 }
278};