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 hkbClipGeneratorEcho {
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 = "offsetLocalTime"))]
32 #[cfg_attr(feature = "serde", serde(rename = "offsetLocalTime"))]
33 pub m_offsetLocalTime: f32,
34 #[cfg_attr(feature = "json_schema", schemars(rename = "weight"))]
39 #[cfg_attr(feature = "serde", serde(rename = "weight"))]
40 pub m_weight: f32,
41 #[cfg_attr(feature = "json_schema", schemars(rename = "dwdt"))]
46 #[cfg_attr(feature = "serde", serde(rename = "dwdt"))]
47 pub m_dwdt: f32,
48}
49const _: () = {
50 use havok_serde as _serde;
51 impl _serde::HavokClass for hkbClipGeneratorEcho {
52 #[inline]
53 fn name(&self) -> &'static str {
54 "hkbClipGeneratorEcho"
55 }
56 #[inline]
57 fn signature(&self) -> _serde::__private::Signature {
58 _serde::__private::Signature::new(0x750edf40)
59 }
60 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
61 fn deps_indexes(&self) -> Vec<usize> {
62 let mut v = Vec::new();
63 v
64 }
65 }
66 impl _serde::Serialize for hkbClipGeneratorEcho {
67 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
68 where
69 S: _serde::ser::Serializer,
70 {
71 let class_meta = self
72 .__ptr
73 .map(|name| (name, _serde::__private::Signature::new(0x750edf40)));
74 let mut serializer = __serializer
75 .serialize_struct("hkbClipGeneratorEcho", class_meta, (16u64, 16u64))?;
76 serializer.serialize_field("offsetLocalTime", &self.m_offsetLocalTime)?;
77 serializer.serialize_field("weight", &self.m_weight)?;
78 serializer.serialize_field("dwdt", &self.m_dwdt)?;
79 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 4usize].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 hkbClipGeneratorEcho {
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_offsetLocalTime,
97 m_weight,
98 m_dwdt,
99 __ignore,
100 }
101 struct __FieldVisitor;
102 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
103 type Value = __Field;
104 fn expecting(
105 &self,
106 __formatter: &mut core::fmt::Formatter,
107 ) -> core::fmt::Result {
108 core::fmt::Formatter::write_str(__formatter, "field identifier")
109 }
110 #[allow(clippy::match_single_binding)]
112 #[allow(clippy::reversed_empty_ranges)]
113 #[allow(clippy::single_match)]
114 fn visit_key<__E>(
115 self,
116 __value: &str,
117 ) -> core::result::Result<Self::Value, __E>
118 where
119 __E: _serde::de::Error,
120 {
121 match __value {
122 "offsetLocalTime" => Ok(__Field::m_offsetLocalTime),
123 "weight" => Ok(__Field::m_weight),
124 "dwdt" => Ok(__Field::m_dwdt),
125 _ => Ok(__Field::__ignore),
126 }
127 }
128 }
129 impl<'de> _serde::Deserialize<'de> for __Field {
130 #[inline]
131 fn deserialize<__D>(
132 __deserializer: __D,
133 ) -> core::result::Result<Self, __D::Error>
134 where
135 __D: _serde::Deserializer<'de>,
136 {
137 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
138 }
139 }
140 struct __hkbClipGeneratorEchoVisitor<'de> {
141 marker: _serde::__private::PhantomData<hkbClipGeneratorEcho>,
142 lifetime: _serde::__private::PhantomData<&'de ()>,
143 }
144 #[allow(clippy::match_single_binding)]
145 #[allow(clippy::reversed_empty_ranges)]
146 #[allow(clippy::single_match)]
147 impl<'de> _serde::de::Visitor<'de> for __hkbClipGeneratorEchoVisitor<'de> {
148 type Value = hkbClipGeneratorEcho;
149 fn expecting(
150 &self,
151 __formatter: &mut core::fmt::Formatter,
152 ) -> core::fmt::Result {
153 core::fmt::Formatter::write_str(
154 __formatter,
155 "struct hkbClipGeneratorEcho",
156 )
157 }
158 fn visit_struct_for_bytes<__A>(
159 self,
160 mut __map: __A,
161 ) -> _serde::__private::Result<Self::Value, __A::Error>
162 where
163 __A: _serde::de::MapAccess<'de>,
164 {
165 let __ptr = __A::class_ptr(&mut __map);
166 let mut m_offsetLocalTime: _serde::__private::Option<f32> = _serde::__private::None;
167 let mut m_weight: _serde::__private::Option<f32> = _serde::__private::None;
168 let mut m_dwdt: _serde::__private::Option<f32> = _serde::__private::None;
169 for i in 0..3usize {
170 match i {
171 0usize => {
172 if _serde::__private::Option::is_some(&m_offsetLocalTime) {
173 return _serde::__private::Err(
174 <__A::Error as _serde::de::Error>::duplicate_field(
175 "offsetLocalTime",
176 ),
177 );
178 }
179 m_offsetLocalTime = _serde::__private::Some(
180 match __A::next_value::<f32>(&mut __map) {
181 _serde::__private::Ok(__val) => __val,
182 _serde::__private::Err(__err) => {
183 return _serde::__private::Err(__err);
184 }
185 },
186 );
187 }
188 1usize => {
189 if _serde::__private::Option::is_some(&m_weight) {
190 return _serde::__private::Err(
191 <__A::Error as _serde::de::Error>::duplicate_field("weight"),
192 );
193 }
194 m_weight = _serde::__private::Some(
195 match __A::next_value::<f32>(&mut __map) {
196 _serde::__private::Ok(__val) => __val,
197 _serde::__private::Err(__err) => {
198 return _serde::__private::Err(__err);
199 }
200 },
201 );
202 }
203 2usize => {
204 if _serde::__private::Option::is_some(&m_dwdt) {
205 return _serde::__private::Err(
206 <__A::Error as _serde::de::Error>::duplicate_field("dwdt"),
207 );
208 }
209 m_dwdt = _serde::__private::Some(
210 match __A::next_value::<f32>(&mut __map) {
211 _serde::__private::Ok(__val) => __val,
212 _serde::__private::Err(__err) => {
213 return _serde::__private::Err(__err);
214 }
215 },
216 );
217 }
218 _ => {}
219 }
220 }
221 __A::pad(&mut __map, 4usize, 4usize)?;
222 let m_offsetLocalTime = match m_offsetLocalTime {
223 _serde::__private::Some(__field) => __field,
224 _serde::__private::None => {
225 return _serde::__private::Err(
226 <__A::Error as _serde::de::Error>::missing_field(
227 "offsetLocalTime",
228 ),
229 );
230 }
231 };
232 let m_weight = match m_weight {
233 _serde::__private::Some(__field) => __field,
234 _serde::__private::None => {
235 return _serde::__private::Err(
236 <__A::Error as _serde::de::Error>::missing_field("weight"),
237 );
238 }
239 };
240 let m_dwdt = match m_dwdt {
241 _serde::__private::Some(__field) => __field,
242 _serde::__private::None => {
243 return _serde::__private::Err(
244 <__A::Error as _serde::de::Error>::missing_field("dwdt"),
245 );
246 }
247 };
248 _serde::__private::Ok(hkbClipGeneratorEcho {
249 __ptr,
250 m_offsetLocalTime,
251 m_weight,
252 m_dwdt,
253 })
254 }
255 #[allow(clippy::manual_unwrap_or_default)]
256 fn visit_struct<__A>(
257 self,
258 mut __map: __A,
259 ) -> _serde::__private::Result<Self::Value, __A::Error>
260 where
261 __A: _serde::de::MapAccess<'de>,
262 {
263 let mut m_offsetLocalTime: _serde::__private::Option<f32> = _serde::__private::None;
264 let mut m_weight: _serde::__private::Option<f32> = _serde::__private::None;
265 let mut m_dwdt: _serde::__private::Option<f32> = _serde::__private::None;
266 while let _serde::__private::Some(__key) = {
267 __A::next_key::<__Field>(&mut __map)?
268 } {
269 match __key {
270 __Field::m_offsetLocalTime => {
271 #[cfg(
272 any(feature = "strict", feature = "ignore_duplicates")
273 )]
274 if _serde::__private::Option::is_some(&m_offsetLocalTime) {
275 #[cfg(feature = "ignore_duplicates")]
276 {
277 __A::skip_value(&mut __map)?;
278 continue;
279 }
280 #[cfg(feature = "strict")]
281 return _serde::__private::Err(
282 <__A::Error as _serde::de::Error>::duplicate_field(
283 "offsetLocalTime",
284 ),
285 );
286 }
287 m_offsetLocalTime = _serde::__private::Some(
288 match __A::next_value::<f32>(&mut __map) {
289 _serde::__private::Ok(__val) => __val,
290 _serde::__private::Err(__err) => {
291 return _serde::__private::Err(__err);
292 }
293 },
294 );
295 }
296 __Field::m_weight => {
297 #[cfg(
298 any(feature = "strict", feature = "ignore_duplicates")
299 )]
300 if _serde::__private::Option::is_some(&m_weight) {
301 #[cfg(feature = "ignore_duplicates")]
302 {
303 __A::skip_value(&mut __map)?;
304 continue;
305 }
306 #[cfg(feature = "strict")]
307 return _serde::__private::Err(
308 <__A::Error as _serde::de::Error>::duplicate_field("weight"),
309 );
310 }
311 m_weight = _serde::__private::Some(
312 match __A::next_value::<f32>(&mut __map) {
313 _serde::__private::Ok(__val) => __val,
314 _serde::__private::Err(__err) => {
315 return _serde::__private::Err(__err);
316 }
317 },
318 );
319 }
320 __Field::m_dwdt => {
321 #[cfg(
322 any(feature = "strict", feature = "ignore_duplicates")
323 )]
324 if _serde::__private::Option::is_some(&m_dwdt) {
325 #[cfg(feature = "ignore_duplicates")]
326 {
327 __A::skip_value(&mut __map)?;
328 continue;
329 }
330 #[cfg(feature = "strict")]
331 return _serde::__private::Err(
332 <__A::Error as _serde::de::Error>::duplicate_field("dwdt"),
333 );
334 }
335 m_dwdt = _serde::__private::Some(
336 match __A::next_value::<f32>(&mut __map) {
337 _serde::__private::Ok(__val) => __val,
338 _serde::__private::Err(__err) => {
339 return _serde::__private::Err(__err);
340 }
341 },
342 );
343 }
344 _ => __A::skip_value(&mut __map)?,
345 }
346 }
347 let m_offsetLocalTime = match m_offsetLocalTime {
348 _serde::__private::Some(__field) => __field,
349 _serde::__private::None => {
350 #[cfg(feature = "strict")]
351 return _serde::__private::Err(
352 <__A::Error as _serde::de::Error>::missing_field(
353 "offsetLocalTime",
354 ),
355 );
356 #[cfg(not(feature = "strict"))] Default::default()
357 }
358 };
359 let m_weight = match m_weight {
360 _serde::__private::Some(__field) => __field,
361 _serde::__private::None => {
362 #[cfg(feature = "strict")]
363 return _serde::__private::Err(
364 <__A::Error as _serde::de::Error>::missing_field("weight"),
365 );
366 #[cfg(not(feature = "strict"))] Default::default()
367 }
368 };
369 let m_dwdt = match m_dwdt {
370 _serde::__private::Some(__field) => __field,
371 _serde::__private::None => {
372 #[cfg(feature = "strict")]
373 return _serde::__private::Err(
374 <__A::Error as _serde::de::Error>::missing_field("dwdt"),
375 );
376 #[cfg(not(feature = "strict"))] Default::default()
377 }
378 };
379 let __ptr = __A::class_ptr(&mut __map);
380 _serde::__private::Ok(hkbClipGeneratorEcho {
381 __ptr,
382 m_offsetLocalTime,
383 m_weight,
384 m_dwdt,
385 })
386 }
387 }
388 const FIELDS: &[&str] = &["offsetLocalTime", "weight", "dwdt"];
389 _serde::Deserializer::deserialize_struct(
390 deserializer,
391 "hkbClipGeneratorEcho",
392 FIELDS,
393 __hkbClipGeneratorEchoVisitor {
394 marker: _serde::__private::PhantomData::<hkbClipGeneratorEcho>,
395 lifetime: _serde::__private::PhantomData,
396 },
397 )
398 }
399 }
400};