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 hkbClipGeneratorInternalState {
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 = "extractedMotion"))]
35 #[cfg_attr(feature = "serde", serde(rename = "extractedMotion"))]
36 pub m_extractedMotion: QsTransform,
37 #[cfg_attr(feature = "json_schema", schemars(rename = "echos"))]
42 #[cfg_attr(feature = "serde", serde(rename = "echos"))]
43 pub m_echos: Vec<hkbClipGeneratorEcho>,
44 #[cfg_attr(feature = "json_schema", schemars(rename = "localTime"))]
49 #[cfg_attr(feature = "serde", serde(rename = "localTime"))]
50 pub m_localTime: f32,
51 #[cfg_attr(feature = "json_schema", schemars(rename = "time"))]
56 #[cfg_attr(feature = "serde", serde(rename = "time"))]
57 pub m_time: f32,
58 #[cfg_attr(
63 feature = "json_schema",
64 schemars(rename = "previousUserControlledTimeFraction")
65 )]
66 #[cfg_attr(feature = "serde", serde(rename = "previousUserControlledTimeFraction"))]
67 pub m_previousUserControlledTimeFraction: f32,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "bufferSize"))]
73 #[cfg_attr(feature = "serde", serde(rename = "bufferSize"))]
74 pub m_bufferSize: i32,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "echoBufferSize"))]
80 #[cfg_attr(feature = "serde", serde(rename = "echoBufferSize"))]
81 pub m_echoBufferSize: i32,
82 #[cfg_attr(feature = "json_schema", schemars(rename = "atEnd"))]
87 #[cfg_attr(feature = "serde", serde(rename = "atEnd"))]
88 pub m_atEnd: bool,
89 #[cfg_attr(feature = "json_schema", schemars(rename = "ignoreStartTime"))]
94 #[cfg_attr(feature = "serde", serde(rename = "ignoreStartTime"))]
95 pub m_ignoreStartTime: bool,
96 #[cfg_attr(feature = "json_schema", schemars(rename = "pingPongBackward"))]
101 #[cfg_attr(feature = "serde", serde(rename = "pingPongBackward"))]
102 pub m_pingPongBackward: bool,
103}
104const _: () = {
105 use havok_serde as _serde;
106 impl _serde::HavokClass for hkbClipGeneratorInternalState {
107 #[inline]
108 fn name(&self) -> &'static str {
109 "hkbClipGeneratorInternalState"
110 }
111 #[inline]
112 fn signature(&self) -> _serde::__private::Signature {
113 _serde::__private::Signature::new(0x26ce5bf3)
114 }
115 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
116 fn deps_indexes(&self) -> Vec<usize> {
117 let mut v = Vec::new();
118 v.extend(
119 self
120 .m_echos
121 .iter()
122 .flat_map(|class| class.deps_indexes())
123 .collect::<Vec<usize>>(),
124 );
125 v
126 }
127 }
128 impl _serde::Serialize for hkbClipGeneratorInternalState {
129 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
130 where
131 S: _serde::ser::Serializer,
132 {
133 let class_meta = self
134 .__ptr
135 .map(|name| (name, _serde::__private::Signature::new(0x26ce5bf3)));
136 let mut serializer = __serializer
137 .serialize_struct(
138 "hkbClipGeneratorInternalState",
139 class_meta,
140 (112u64, 112u64),
141 )?;
142 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
143 serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
144 serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
145 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
146 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
147 serializer.serialize_field("extractedMotion", &self.m_extractedMotion)?;
148 serializer
149 .serialize_array_field(
150 "echos",
151 &self.m_echos,
152 TypeSize::Struct {
153 size_x86: 16u64,
154 size_x86_64: 16u64,
155 },
156 )?;
157 serializer.serialize_field("localTime", &self.m_localTime)?;
158 serializer.serialize_field("time", &self.m_time)?;
159 serializer
160 .serialize_field(
161 "previousUserControlledTimeFraction",
162 &self.m_previousUserControlledTimeFraction,
163 )?;
164 serializer.serialize_field("bufferSize", &self.m_bufferSize)?;
165 serializer.serialize_field("echoBufferSize", &self.m_echoBufferSize)?;
166 serializer.serialize_field("atEnd", &self.m_atEnd)?;
167 serializer.serialize_field("ignoreStartTime", &self.m_ignoreStartTime)?;
168 serializer.serialize_field("pingPongBackward", &self.m_pingPongBackward)?;
169 serializer.pad_field([0u8; 13usize].as_slice(), [0u8; 9usize].as_slice())?;
170 serializer.end()
171 }
172 }
173};
174#[doc(hidden)]
175#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
176const _: () = {
177 use havok_serde as _serde;
178 #[automatically_derived]
179 impl<'de> _serde::Deserialize<'de> for hkbClipGeneratorInternalState {
180 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
181 where
182 __D: _serde::Deserializer<'de>,
183 {
184 #[allow(non_camel_case_types)]
185 enum __Field {
186 m_extractedMotion,
187 m_echos,
188 m_localTime,
189 m_time,
190 m_previousUserControlledTimeFraction,
191 m_bufferSize,
192 m_echoBufferSize,
193 m_atEnd,
194 m_ignoreStartTime,
195 m_pingPongBackward,
196 __ignore,
197 }
198 struct __FieldVisitor;
199 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
200 type Value = __Field;
201 fn expecting(
202 &self,
203 __formatter: &mut core::fmt::Formatter,
204 ) -> core::fmt::Result {
205 core::fmt::Formatter::write_str(__formatter, "field identifier")
206 }
207 #[allow(clippy::match_single_binding)]
209 #[allow(clippy::reversed_empty_ranges)]
210 #[allow(clippy::single_match)]
211 fn visit_key<__E>(
212 self,
213 __value: &str,
214 ) -> core::result::Result<Self::Value, __E>
215 where
216 __E: _serde::de::Error,
217 {
218 match __value {
219 "extractedMotion" => Ok(__Field::m_extractedMotion),
220 "echos" => Ok(__Field::m_echos),
221 "localTime" => Ok(__Field::m_localTime),
222 "time" => Ok(__Field::m_time),
223 "previousUserControlledTimeFraction" => {
224 Ok(__Field::m_previousUserControlledTimeFraction)
225 }
226 "bufferSize" => Ok(__Field::m_bufferSize),
227 "echoBufferSize" => Ok(__Field::m_echoBufferSize),
228 "atEnd" => Ok(__Field::m_atEnd),
229 "ignoreStartTime" => Ok(__Field::m_ignoreStartTime),
230 "pingPongBackward" => Ok(__Field::m_pingPongBackward),
231 _ => Ok(__Field::__ignore),
232 }
233 }
234 }
235 impl<'de> _serde::Deserialize<'de> for __Field {
236 #[inline]
237 fn deserialize<__D>(
238 __deserializer: __D,
239 ) -> core::result::Result<Self, __D::Error>
240 where
241 __D: _serde::Deserializer<'de>,
242 {
243 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
244 }
245 }
246 struct __hkbClipGeneratorInternalStateVisitor<'de> {
247 marker: _serde::__private::PhantomData<hkbClipGeneratorInternalState>,
248 lifetime: _serde::__private::PhantomData<&'de ()>,
249 }
250 #[allow(clippy::match_single_binding)]
251 #[allow(clippy::reversed_empty_ranges)]
252 #[allow(clippy::single_match)]
253 impl<'de> _serde::de::Visitor<'de>
254 for __hkbClipGeneratorInternalStateVisitor<'de> {
255 type Value = hkbClipGeneratorInternalState;
256 fn expecting(
257 &self,
258 __formatter: &mut core::fmt::Formatter,
259 ) -> core::fmt::Result {
260 core::fmt::Formatter::write_str(
261 __formatter,
262 "struct hkbClipGeneratorInternalState",
263 )
264 }
265 fn visit_struct_for_bytes<__A>(
266 self,
267 mut __map: __A,
268 ) -> _serde::__private::Result<Self::Value, __A::Error>
269 where
270 __A: _serde::de::MapAccess<'de>,
271 {
272 let __ptr = __A::class_ptr(&mut __map);
273 let parent = __A::parent_value(&mut __map)?;
274 let mut m_extractedMotion: _serde::__private::Option<QsTransform> = _serde::__private::None;
275 let mut m_echos: _serde::__private::Option<
276 Vec<hkbClipGeneratorEcho>,
277 > = _serde::__private::None;
278 let mut m_localTime: _serde::__private::Option<f32> = _serde::__private::None;
279 let mut m_time: _serde::__private::Option<f32> = _serde::__private::None;
280 let mut m_previousUserControlledTimeFraction: _serde::__private::Option<
281 f32,
282 > = _serde::__private::None;
283 let mut m_bufferSize: _serde::__private::Option<i32> = _serde::__private::None;
284 let mut m_echoBufferSize: _serde::__private::Option<i32> = _serde::__private::None;
285 let mut m_atEnd: _serde::__private::Option<bool> = _serde::__private::None;
286 let mut m_ignoreStartTime: _serde::__private::Option<bool> = _serde::__private::None;
287 let mut m_pingPongBackward: _serde::__private::Option<bool> = _serde::__private::None;
288 for i in 0..10usize {
289 match i {
290 0usize => {
291 if _serde::__private::Option::is_some(&m_extractedMotion) {
292 return _serde::__private::Err(
293 <__A::Error as _serde::de::Error>::duplicate_field(
294 "extractedMotion",
295 ),
296 );
297 }
298 __A::pad(&mut __map, 8usize, 0usize)?;
299 m_extractedMotion = _serde::__private::Some(
300 match __A::next_value::<QsTransform>(&mut __map) {
301 _serde::__private::Ok(__val) => __val,
302 _serde::__private::Err(__err) => {
303 return _serde::__private::Err(__err);
304 }
305 },
306 );
307 }
308 1usize => {
309 if _serde::__private::Option::is_some(&m_echos) {
310 return _serde::__private::Err(
311 <__A::Error as _serde::de::Error>::duplicate_field("echos"),
312 );
313 }
314 m_echos = _serde::__private::Some(
315 match __A::next_value::<
316 Vec<hkbClipGeneratorEcho>,
317 >(&mut __map) {
318 _serde::__private::Ok(__val) => __val,
319 _serde::__private::Err(__err) => {
320 return _serde::__private::Err(__err);
321 }
322 },
323 );
324 }
325 2usize => {
326 if _serde::__private::Option::is_some(&m_localTime) {
327 return _serde::__private::Err(
328 <__A::Error as _serde::de::Error>::duplicate_field(
329 "localTime",
330 ),
331 );
332 }
333 m_localTime = _serde::__private::Some(
334 match __A::next_value::<f32>(&mut __map) {
335 _serde::__private::Ok(__val) => __val,
336 _serde::__private::Err(__err) => {
337 return _serde::__private::Err(__err);
338 }
339 },
340 );
341 }
342 3usize => {
343 if _serde::__private::Option::is_some(&m_time) {
344 return _serde::__private::Err(
345 <__A::Error as _serde::de::Error>::duplicate_field("time"),
346 );
347 }
348 m_time = _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 4usize => {
358 if _serde::__private::Option::is_some(
359 &m_previousUserControlledTimeFraction,
360 ) {
361 return _serde::__private::Err(
362 <__A::Error as _serde::de::Error>::duplicate_field(
363 "previousUserControlledTimeFraction",
364 ),
365 );
366 }
367 m_previousUserControlledTimeFraction = _serde::__private::Some(
368 match __A::next_value::<f32>(&mut __map) {
369 _serde::__private::Ok(__val) => __val,
370 _serde::__private::Err(__err) => {
371 return _serde::__private::Err(__err);
372 }
373 },
374 );
375 }
376 5usize => {
377 if _serde::__private::Option::is_some(&m_bufferSize) {
378 return _serde::__private::Err(
379 <__A::Error as _serde::de::Error>::duplicate_field(
380 "bufferSize",
381 ),
382 );
383 }
384 m_bufferSize = _serde::__private::Some(
385 match __A::next_value::<i32>(&mut __map) {
386 _serde::__private::Ok(__val) => __val,
387 _serde::__private::Err(__err) => {
388 return _serde::__private::Err(__err);
389 }
390 },
391 );
392 }
393 6usize => {
394 if _serde::__private::Option::is_some(&m_echoBufferSize) {
395 return _serde::__private::Err(
396 <__A::Error as _serde::de::Error>::duplicate_field(
397 "echoBufferSize",
398 ),
399 );
400 }
401 m_echoBufferSize = _serde::__private::Some(
402 match __A::next_value::<i32>(&mut __map) {
403 _serde::__private::Ok(__val) => __val,
404 _serde::__private::Err(__err) => {
405 return _serde::__private::Err(__err);
406 }
407 },
408 );
409 }
410 7usize => {
411 if _serde::__private::Option::is_some(&m_atEnd) {
412 return _serde::__private::Err(
413 <__A::Error as _serde::de::Error>::duplicate_field("atEnd"),
414 );
415 }
416 m_atEnd = _serde::__private::Some(
417 match __A::next_value::<bool>(&mut __map) {
418 _serde::__private::Ok(__val) => __val,
419 _serde::__private::Err(__err) => {
420 return _serde::__private::Err(__err);
421 }
422 },
423 );
424 }
425 8usize => {
426 if _serde::__private::Option::is_some(&m_ignoreStartTime) {
427 return _serde::__private::Err(
428 <__A::Error as _serde::de::Error>::duplicate_field(
429 "ignoreStartTime",
430 ),
431 );
432 }
433 m_ignoreStartTime = _serde::__private::Some(
434 match __A::next_value::<bool>(&mut __map) {
435 _serde::__private::Ok(__val) => __val,
436 _serde::__private::Err(__err) => {
437 return _serde::__private::Err(__err);
438 }
439 },
440 );
441 }
442 9usize => {
443 if _serde::__private::Option::is_some(&m_pingPongBackward) {
444 return _serde::__private::Err(
445 <__A::Error as _serde::de::Error>::duplicate_field(
446 "pingPongBackward",
447 ),
448 );
449 }
450 m_pingPongBackward = _serde::__private::Some(
451 match __A::next_value::<bool>(&mut __map) {
452 _serde::__private::Ok(__val) => __val,
453 _serde::__private::Err(__err) => {
454 return _serde::__private::Err(__err);
455 }
456 },
457 );
458 }
459 _ => {}
460 }
461 }
462 __A::pad(&mut __map, 13usize, 9usize)?;
463 let m_extractedMotion = match m_extractedMotion {
464 _serde::__private::Some(__field) => __field,
465 _serde::__private::None => {
466 return _serde::__private::Err(
467 <__A::Error as _serde::de::Error>::missing_field(
468 "extractedMotion",
469 ),
470 );
471 }
472 };
473 let m_echos = match m_echos {
474 _serde::__private::Some(__field) => __field,
475 _serde::__private::None => {
476 return _serde::__private::Err(
477 <__A::Error as _serde::de::Error>::missing_field("echos"),
478 );
479 }
480 };
481 let m_localTime = match m_localTime {
482 _serde::__private::Some(__field) => __field,
483 _serde::__private::None => {
484 return _serde::__private::Err(
485 <__A::Error as _serde::de::Error>::missing_field(
486 "localTime",
487 ),
488 );
489 }
490 };
491 let m_time = match m_time {
492 _serde::__private::Some(__field) => __field,
493 _serde::__private::None => {
494 return _serde::__private::Err(
495 <__A::Error as _serde::de::Error>::missing_field("time"),
496 );
497 }
498 };
499 let m_previousUserControlledTimeFraction = match m_previousUserControlledTimeFraction {
500 _serde::__private::Some(__field) => __field,
501 _serde::__private::None => {
502 return _serde::__private::Err(
503 <__A::Error as _serde::de::Error>::missing_field(
504 "previousUserControlledTimeFraction",
505 ),
506 );
507 }
508 };
509 let m_bufferSize = match m_bufferSize {
510 _serde::__private::Some(__field) => __field,
511 _serde::__private::None => {
512 return _serde::__private::Err(
513 <__A::Error as _serde::de::Error>::missing_field(
514 "bufferSize",
515 ),
516 );
517 }
518 };
519 let m_echoBufferSize = match m_echoBufferSize {
520 _serde::__private::Some(__field) => __field,
521 _serde::__private::None => {
522 return _serde::__private::Err(
523 <__A::Error as _serde::de::Error>::missing_field(
524 "echoBufferSize",
525 ),
526 );
527 }
528 };
529 let m_atEnd = match m_atEnd {
530 _serde::__private::Some(__field) => __field,
531 _serde::__private::None => {
532 return _serde::__private::Err(
533 <__A::Error as _serde::de::Error>::missing_field("atEnd"),
534 );
535 }
536 };
537 let m_ignoreStartTime = match m_ignoreStartTime {
538 _serde::__private::Some(__field) => __field,
539 _serde::__private::None => {
540 return _serde::__private::Err(
541 <__A::Error as _serde::de::Error>::missing_field(
542 "ignoreStartTime",
543 ),
544 );
545 }
546 };
547 let m_pingPongBackward = match m_pingPongBackward {
548 _serde::__private::Some(__field) => __field,
549 _serde::__private::None => {
550 return _serde::__private::Err(
551 <__A::Error as _serde::de::Error>::missing_field(
552 "pingPongBackward",
553 ),
554 );
555 }
556 };
557 _serde::__private::Ok(hkbClipGeneratorInternalState {
558 __ptr,
559 parent,
560 m_extractedMotion,
561 m_echos,
562 m_localTime,
563 m_time,
564 m_previousUserControlledTimeFraction,
565 m_bufferSize,
566 m_echoBufferSize,
567 m_atEnd,
568 m_ignoreStartTime,
569 m_pingPongBackward,
570 })
571 }
572 #[allow(clippy::manual_unwrap_or_default)]
573 fn visit_struct<__A>(
574 self,
575 mut __map: __A,
576 ) -> _serde::__private::Result<Self::Value, __A::Error>
577 where
578 __A: _serde::de::MapAccess<'de>,
579 {
580 let mut m_extractedMotion: _serde::__private::Option<QsTransform> = _serde::__private::None;
581 let mut m_echos: _serde::__private::Option<
582 Vec<hkbClipGeneratorEcho>,
583 > = _serde::__private::None;
584 let mut m_localTime: _serde::__private::Option<f32> = _serde::__private::None;
585 let mut m_time: _serde::__private::Option<f32> = _serde::__private::None;
586 let mut m_previousUserControlledTimeFraction: _serde::__private::Option<
587 f32,
588 > = _serde::__private::None;
589 let mut m_bufferSize: _serde::__private::Option<i32> = _serde::__private::None;
590 let mut m_echoBufferSize: _serde::__private::Option<i32> = _serde::__private::None;
591 let mut m_atEnd: _serde::__private::Option<bool> = _serde::__private::None;
592 let mut m_ignoreStartTime: _serde::__private::Option<bool> = _serde::__private::None;
593 let mut m_pingPongBackward: _serde::__private::Option<bool> = _serde::__private::None;
594 while let _serde::__private::Some(__key) = {
595 __A::next_key::<__Field>(&mut __map)?
596 } {
597 match __key {
598 __Field::m_extractedMotion => {
599 #[cfg(
600 any(feature = "strict", feature = "ignore_duplicates")
601 )]
602 if _serde::__private::Option::is_some(&m_extractedMotion) {
603 #[cfg(feature = "ignore_duplicates")]
604 {
605 __A::skip_value(&mut __map)?;
606 continue;
607 }
608 #[cfg(feature = "strict")]
609 return _serde::__private::Err(
610 <__A::Error as _serde::de::Error>::duplicate_field(
611 "extractedMotion",
612 ),
613 );
614 }
615 m_extractedMotion = _serde::__private::Some(
616 match __A::next_value::<QsTransform>(&mut __map) {
617 _serde::__private::Ok(__val) => __val,
618 _serde::__private::Err(__err) => {
619 return _serde::__private::Err(__err);
620 }
621 },
622 );
623 }
624 __Field::m_echos => {
625 #[cfg(
626 any(feature = "strict", feature = "ignore_duplicates")
627 )]
628 if _serde::__private::Option::is_some(&m_echos) {
629 #[cfg(feature = "ignore_duplicates")]
630 {
631 __A::skip_value(&mut __map)?;
632 continue;
633 }
634 #[cfg(feature = "strict")]
635 return _serde::__private::Err(
636 <__A::Error as _serde::de::Error>::duplicate_field("echos"),
637 );
638 }
639 m_echos = _serde::__private::Some(
640 match __A::next_value::<
641 Vec<hkbClipGeneratorEcho>,
642 >(&mut __map) {
643 _serde::__private::Ok(__val) => __val,
644 _serde::__private::Err(__err) => {
645 return _serde::__private::Err(__err);
646 }
647 },
648 );
649 }
650 __Field::m_localTime => {
651 #[cfg(
652 any(feature = "strict", feature = "ignore_duplicates")
653 )]
654 if _serde::__private::Option::is_some(&m_localTime) {
655 #[cfg(feature = "ignore_duplicates")]
656 {
657 __A::skip_value(&mut __map)?;
658 continue;
659 }
660 #[cfg(feature = "strict")]
661 return _serde::__private::Err(
662 <__A::Error as _serde::de::Error>::duplicate_field(
663 "localTime",
664 ),
665 );
666 }
667 m_localTime = _serde::__private::Some(
668 match __A::next_value::<f32>(&mut __map) {
669 _serde::__private::Ok(__val) => __val,
670 _serde::__private::Err(__err) => {
671 return _serde::__private::Err(__err);
672 }
673 },
674 );
675 }
676 __Field::m_time => {
677 #[cfg(
678 any(feature = "strict", feature = "ignore_duplicates")
679 )]
680 if _serde::__private::Option::is_some(&m_time) {
681 #[cfg(feature = "ignore_duplicates")]
682 {
683 __A::skip_value(&mut __map)?;
684 continue;
685 }
686 #[cfg(feature = "strict")]
687 return _serde::__private::Err(
688 <__A::Error as _serde::de::Error>::duplicate_field("time"),
689 );
690 }
691 m_time = _serde::__private::Some(
692 match __A::next_value::<f32>(&mut __map) {
693 _serde::__private::Ok(__val) => __val,
694 _serde::__private::Err(__err) => {
695 return _serde::__private::Err(__err);
696 }
697 },
698 );
699 }
700 __Field::m_previousUserControlledTimeFraction => {
701 #[cfg(
702 any(feature = "strict", feature = "ignore_duplicates")
703 )]
704 if _serde::__private::Option::is_some(
705 &m_previousUserControlledTimeFraction,
706 ) {
707 #[cfg(feature = "ignore_duplicates")]
708 {
709 __A::skip_value(&mut __map)?;
710 continue;
711 }
712 #[cfg(feature = "strict")]
713 return _serde::__private::Err(
714 <__A::Error as _serde::de::Error>::duplicate_field(
715 "previousUserControlledTimeFraction",
716 ),
717 );
718 }
719 m_previousUserControlledTimeFraction = _serde::__private::Some(
720 match __A::next_value::<f32>(&mut __map) {
721 _serde::__private::Ok(__val) => __val,
722 _serde::__private::Err(__err) => {
723 return _serde::__private::Err(__err);
724 }
725 },
726 );
727 }
728 __Field::m_bufferSize => {
729 #[cfg(
730 any(feature = "strict", feature = "ignore_duplicates")
731 )]
732 if _serde::__private::Option::is_some(&m_bufferSize) {
733 #[cfg(feature = "ignore_duplicates")]
734 {
735 __A::skip_value(&mut __map)?;
736 continue;
737 }
738 #[cfg(feature = "strict")]
739 return _serde::__private::Err(
740 <__A::Error as _serde::de::Error>::duplicate_field(
741 "bufferSize",
742 ),
743 );
744 }
745 m_bufferSize = _serde::__private::Some(
746 match __A::next_value::<i32>(&mut __map) {
747 _serde::__private::Ok(__val) => __val,
748 _serde::__private::Err(__err) => {
749 return _serde::__private::Err(__err);
750 }
751 },
752 );
753 }
754 __Field::m_echoBufferSize => {
755 #[cfg(
756 any(feature = "strict", feature = "ignore_duplicates")
757 )]
758 if _serde::__private::Option::is_some(&m_echoBufferSize) {
759 #[cfg(feature = "ignore_duplicates")]
760 {
761 __A::skip_value(&mut __map)?;
762 continue;
763 }
764 #[cfg(feature = "strict")]
765 return _serde::__private::Err(
766 <__A::Error as _serde::de::Error>::duplicate_field(
767 "echoBufferSize",
768 ),
769 );
770 }
771 m_echoBufferSize = _serde::__private::Some(
772 match __A::next_value::<i32>(&mut __map) {
773 _serde::__private::Ok(__val) => __val,
774 _serde::__private::Err(__err) => {
775 return _serde::__private::Err(__err);
776 }
777 },
778 );
779 }
780 __Field::m_atEnd => {
781 #[cfg(
782 any(feature = "strict", feature = "ignore_duplicates")
783 )]
784 if _serde::__private::Option::is_some(&m_atEnd) {
785 #[cfg(feature = "ignore_duplicates")]
786 {
787 __A::skip_value(&mut __map)?;
788 continue;
789 }
790 #[cfg(feature = "strict")]
791 return _serde::__private::Err(
792 <__A::Error as _serde::de::Error>::duplicate_field("atEnd"),
793 );
794 }
795 m_atEnd = _serde::__private::Some(
796 match __A::next_value::<bool>(&mut __map) {
797 _serde::__private::Ok(__val) => __val,
798 _serde::__private::Err(__err) => {
799 return _serde::__private::Err(__err);
800 }
801 },
802 );
803 }
804 __Field::m_ignoreStartTime => {
805 #[cfg(
806 any(feature = "strict", feature = "ignore_duplicates")
807 )]
808 if _serde::__private::Option::is_some(&m_ignoreStartTime) {
809 #[cfg(feature = "ignore_duplicates")]
810 {
811 __A::skip_value(&mut __map)?;
812 continue;
813 }
814 #[cfg(feature = "strict")]
815 return _serde::__private::Err(
816 <__A::Error as _serde::de::Error>::duplicate_field(
817 "ignoreStartTime",
818 ),
819 );
820 }
821 m_ignoreStartTime = _serde::__private::Some(
822 match __A::next_value::<bool>(&mut __map) {
823 _serde::__private::Ok(__val) => __val,
824 _serde::__private::Err(__err) => {
825 return _serde::__private::Err(__err);
826 }
827 },
828 );
829 }
830 __Field::m_pingPongBackward => {
831 #[cfg(
832 any(feature = "strict", feature = "ignore_duplicates")
833 )]
834 if _serde::__private::Option::is_some(&m_pingPongBackward) {
835 #[cfg(feature = "ignore_duplicates")]
836 {
837 __A::skip_value(&mut __map)?;
838 continue;
839 }
840 #[cfg(feature = "strict")]
841 return _serde::__private::Err(
842 <__A::Error as _serde::de::Error>::duplicate_field(
843 "pingPongBackward",
844 ),
845 );
846 }
847 m_pingPongBackward = _serde::__private::Some(
848 match __A::next_value::<bool>(&mut __map) {
849 _serde::__private::Ok(__val) => __val,
850 _serde::__private::Err(__err) => {
851 return _serde::__private::Err(__err);
852 }
853 },
854 );
855 }
856 _ => __A::skip_value(&mut __map)?,
857 }
858 }
859 let m_extractedMotion = match m_extractedMotion {
860 _serde::__private::Some(__field) => __field,
861 _serde::__private::None => {
862 #[cfg(feature = "strict")]
863 return _serde::__private::Err(
864 <__A::Error as _serde::de::Error>::missing_field(
865 "extractedMotion",
866 ),
867 );
868 #[cfg(not(feature = "strict"))] Default::default()
869 }
870 };
871 let m_echos = match m_echos {
872 _serde::__private::Some(__field) => __field,
873 _serde::__private::None => {
874 #[cfg(feature = "strict")]
875 return _serde::__private::Err(
876 <__A::Error as _serde::de::Error>::missing_field("echos"),
877 );
878 #[cfg(not(feature = "strict"))] Default::default()
879 }
880 };
881 let m_localTime = match m_localTime {
882 _serde::__private::Some(__field) => __field,
883 _serde::__private::None => {
884 #[cfg(feature = "strict")]
885 return _serde::__private::Err(
886 <__A::Error as _serde::de::Error>::missing_field(
887 "localTime",
888 ),
889 );
890 #[cfg(not(feature = "strict"))] Default::default()
891 }
892 };
893 let m_time = match m_time {
894 _serde::__private::Some(__field) => __field,
895 _serde::__private::None => {
896 #[cfg(feature = "strict")]
897 return _serde::__private::Err(
898 <__A::Error as _serde::de::Error>::missing_field("time"),
899 );
900 #[cfg(not(feature = "strict"))] Default::default()
901 }
902 };
903 let m_previousUserControlledTimeFraction = match m_previousUserControlledTimeFraction {
904 _serde::__private::Some(__field) => __field,
905 _serde::__private::None => {
906 #[cfg(feature = "strict")]
907 return _serde::__private::Err(
908 <__A::Error as _serde::de::Error>::missing_field(
909 "previousUserControlledTimeFraction",
910 ),
911 );
912 #[cfg(not(feature = "strict"))] Default::default()
913 }
914 };
915 let m_bufferSize = match m_bufferSize {
916 _serde::__private::Some(__field) => __field,
917 _serde::__private::None => {
918 #[cfg(feature = "strict")]
919 return _serde::__private::Err(
920 <__A::Error as _serde::de::Error>::missing_field(
921 "bufferSize",
922 ),
923 );
924 #[cfg(not(feature = "strict"))] Default::default()
925 }
926 };
927 let m_echoBufferSize = match m_echoBufferSize {
928 _serde::__private::Some(__field) => __field,
929 _serde::__private::None => {
930 #[cfg(feature = "strict")]
931 return _serde::__private::Err(
932 <__A::Error as _serde::de::Error>::missing_field(
933 "echoBufferSize",
934 ),
935 );
936 #[cfg(not(feature = "strict"))] Default::default()
937 }
938 };
939 let m_atEnd = match m_atEnd {
940 _serde::__private::Some(__field) => __field,
941 _serde::__private::None => {
942 #[cfg(feature = "strict")]
943 return _serde::__private::Err(
944 <__A::Error as _serde::de::Error>::missing_field("atEnd"),
945 );
946 #[cfg(not(feature = "strict"))] Default::default()
947 }
948 };
949 let m_ignoreStartTime = match m_ignoreStartTime {
950 _serde::__private::Some(__field) => __field,
951 _serde::__private::None => {
952 #[cfg(feature = "strict")]
953 return _serde::__private::Err(
954 <__A::Error as _serde::de::Error>::missing_field(
955 "ignoreStartTime",
956 ),
957 );
958 #[cfg(not(feature = "strict"))] Default::default()
959 }
960 };
961 let m_pingPongBackward = match m_pingPongBackward {
962 _serde::__private::Some(__field) => __field,
963 _serde::__private::None => {
964 #[cfg(feature = "strict")]
965 return _serde::__private::Err(
966 <__A::Error as _serde::de::Error>::missing_field(
967 "pingPongBackward",
968 ),
969 );
970 #[cfg(not(feature = "strict"))] Default::default()
971 }
972 };
973 let __ptr = None;
974 let parent = hkBaseObject { __ptr };
975 let parent = hkReferencedObject {
976 __ptr,
977 parent,
978 ..Default::default()
979 };
980 let __ptr = __A::class_ptr(&mut __map);
981 _serde::__private::Ok(hkbClipGeneratorInternalState {
982 __ptr,
983 parent,
984 m_extractedMotion,
985 m_echos,
986 m_localTime,
987 m_time,
988 m_previousUserControlledTimeFraction,
989 m_bufferSize,
990 m_echoBufferSize,
991 m_atEnd,
992 m_ignoreStartTime,
993 m_pingPongBackward,
994 })
995 }
996 }
997 const FIELDS: &[&str] = &[
998 "extractedMotion",
999 "echos",
1000 "localTime",
1001 "time",
1002 "previousUserControlledTimeFraction",
1003 "bufferSize",
1004 "echoBufferSize",
1005 "atEnd",
1006 "ignoreStartTime",
1007 "pingPongBackward",
1008 ];
1009 _serde::Deserializer::deserialize_struct(
1010 deserializer,
1011 "hkbClipGeneratorInternalState",
1012 FIELDS,
1013 __hkbClipGeneratorInternalStateVisitor {
1014 marker: _serde::__private::PhantomData::<
1015 hkbClipGeneratorInternalState,
1016 >,
1017 lifetime: _serde::__private::PhantomData,
1018 },
1019 )
1020 }
1021 }
1022};