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 hkbGeneratorSyncInfo {
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 = "syncPoints"))]
31 #[cfg_attr(feature = "serde", serde(rename = "syncPoints"))]
32 pub m_syncPoints: [hkbGeneratorSyncInfoSyncPoint; 8usize],
33 #[cfg_attr(feature = "json_schema", schemars(rename = "baseFrequency"))]
38 #[cfg_attr(feature = "serde", serde(rename = "baseFrequency"))]
39 pub m_baseFrequency: f32,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "localTime"))]
45 #[cfg_attr(feature = "serde", serde(rename = "localTime"))]
46 pub m_localTime: f32,
47 #[cfg_attr(feature = "json_schema", schemars(rename = "playbackSpeed"))]
52 #[cfg_attr(feature = "serde", serde(rename = "playbackSpeed"))]
53 pub m_playbackSpeed: f32,
54 #[cfg_attr(feature = "json_schema", schemars(rename = "numSyncPoints"))]
59 #[cfg_attr(feature = "serde", serde(rename = "numSyncPoints"))]
60 pub m_numSyncPoints: i8,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "isCyclic"))]
66 #[cfg_attr(feature = "serde", serde(rename = "isCyclic"))]
67 pub m_isCyclic: bool,
68 #[cfg_attr(feature = "json_schema", schemars(rename = "isMirrored"))]
73 #[cfg_attr(feature = "serde", serde(rename = "isMirrored"))]
74 pub m_isMirrored: bool,
75 #[cfg_attr(feature = "json_schema", schemars(rename = "isAdditive"))]
80 #[cfg_attr(feature = "serde", serde(rename = "isAdditive"))]
81 pub m_isAdditive: bool,
82}
83const _: () = {
84 use havok_serde as _serde;
85 impl _serde::HavokClass for hkbGeneratorSyncInfo {
86 #[inline]
87 fn name(&self) -> &'static str {
88 "hkbGeneratorSyncInfo"
89 }
90 #[inline]
91 fn signature(&self) -> _serde::__private::Signature {
92 _serde::__private::Signature::new(0xa3c341f8)
93 }
94 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
95 fn deps_indexes(&self) -> Vec<usize> {
96 let mut v = Vec::new();
97 v.extend(
98 self
99 .m_syncPoints
100 .iter()
101 .flat_map(|class| class.deps_indexes())
102 .collect::<Vec<usize>>(),
103 );
104 v
105 }
106 }
107 impl _serde::Serialize for hkbGeneratorSyncInfo {
108 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
109 where
110 S: _serde::ser::Serializer,
111 {
112 let class_meta = self
113 .__ptr
114 .map(|name| (name, _serde::__private::Signature::new(0xa3c341f8)));
115 let mut serializer = __serializer
116 .serialize_struct("hkbGeneratorSyncInfo", class_meta, (80u64, 80u64))?;
117 serializer
118 .serialize_fixed_array_field(
119 "syncPoints",
120 self.m_syncPoints.as_slice(),
121 TypeSize::Struct {
122 size_x86: 8u64,
123 size_x86_64: 8u64,
124 },
125 )?;
126 serializer.serialize_field("baseFrequency", &self.m_baseFrequency)?;
127 serializer.serialize_field("localTime", &self.m_localTime)?;
128 serializer.serialize_field("playbackSpeed", &self.m_playbackSpeed)?;
129 serializer.serialize_field("numSyncPoints", &self.m_numSyncPoints)?;
130 serializer.serialize_field("isCyclic", &self.m_isCyclic)?;
131 serializer.serialize_field("isMirrored", &self.m_isMirrored)?;
132 serializer.serialize_field("isAdditive", &self.m_isAdditive)?;
133 serializer.end()
134 }
135 }
136};
137#[doc(hidden)]
138#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
139const _: () = {
140 use havok_serde as _serde;
141 #[automatically_derived]
142 impl<'de> _serde::Deserialize<'de> for hkbGeneratorSyncInfo {
143 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
144 where
145 __D: _serde::Deserializer<'de>,
146 {
147 #[allow(non_camel_case_types)]
148 enum __Field {
149 m_syncPoints,
150 m_baseFrequency,
151 m_localTime,
152 m_playbackSpeed,
153 m_numSyncPoints,
154 m_isCyclic,
155 m_isMirrored,
156 m_isAdditive,
157 __ignore,
158 }
159 struct __FieldVisitor;
160 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
161 type Value = __Field;
162 fn expecting(
163 &self,
164 __formatter: &mut core::fmt::Formatter,
165 ) -> core::fmt::Result {
166 core::fmt::Formatter::write_str(__formatter, "field identifier")
167 }
168 #[allow(clippy::match_single_binding)]
170 #[allow(clippy::reversed_empty_ranges)]
171 #[allow(clippy::single_match)]
172 fn visit_key<__E>(
173 self,
174 __value: &str,
175 ) -> core::result::Result<Self::Value, __E>
176 where
177 __E: _serde::de::Error,
178 {
179 match __value {
180 "syncPoints" => Ok(__Field::m_syncPoints),
181 "baseFrequency" => Ok(__Field::m_baseFrequency),
182 "localTime" => Ok(__Field::m_localTime),
183 "playbackSpeed" => Ok(__Field::m_playbackSpeed),
184 "numSyncPoints" => Ok(__Field::m_numSyncPoints),
185 "isCyclic" => Ok(__Field::m_isCyclic),
186 "isMirrored" => Ok(__Field::m_isMirrored),
187 "isAdditive" => Ok(__Field::m_isAdditive),
188 _ => Ok(__Field::__ignore),
189 }
190 }
191 }
192 impl<'de> _serde::Deserialize<'de> for __Field {
193 #[inline]
194 fn deserialize<__D>(
195 __deserializer: __D,
196 ) -> core::result::Result<Self, __D::Error>
197 where
198 __D: _serde::Deserializer<'de>,
199 {
200 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
201 }
202 }
203 struct __hkbGeneratorSyncInfoVisitor<'de> {
204 marker: _serde::__private::PhantomData<hkbGeneratorSyncInfo>,
205 lifetime: _serde::__private::PhantomData<&'de ()>,
206 }
207 #[allow(clippy::match_single_binding)]
208 #[allow(clippy::reversed_empty_ranges)]
209 #[allow(clippy::single_match)]
210 impl<'de> _serde::de::Visitor<'de> for __hkbGeneratorSyncInfoVisitor<'de> {
211 type Value = hkbGeneratorSyncInfo;
212 fn expecting(
213 &self,
214 __formatter: &mut core::fmt::Formatter,
215 ) -> core::fmt::Result {
216 core::fmt::Formatter::write_str(
217 __formatter,
218 "struct hkbGeneratorSyncInfo",
219 )
220 }
221 fn visit_struct_for_bytes<__A>(
222 self,
223 mut __map: __A,
224 ) -> _serde::__private::Result<Self::Value, __A::Error>
225 where
226 __A: _serde::de::MapAccess<'de>,
227 {
228 let __ptr = __A::class_ptr(&mut __map);
229 let mut m_syncPoints: _serde::__private::Option<
230 [hkbGeneratorSyncInfoSyncPoint; 8usize],
231 > = _serde::__private::None;
232 let mut m_baseFrequency: _serde::__private::Option<f32> = _serde::__private::None;
233 let mut m_localTime: _serde::__private::Option<f32> = _serde::__private::None;
234 let mut m_playbackSpeed: _serde::__private::Option<f32> = _serde::__private::None;
235 let mut m_numSyncPoints: _serde::__private::Option<i8> = _serde::__private::None;
236 let mut m_isCyclic: _serde::__private::Option<bool> = _serde::__private::None;
237 let mut m_isMirrored: _serde::__private::Option<bool> = _serde::__private::None;
238 let mut m_isAdditive: _serde::__private::Option<bool> = _serde::__private::None;
239 for i in 0..8usize {
240 match i {
241 0usize => {
242 if _serde::__private::Option::is_some(&m_syncPoints) {
243 return _serde::__private::Err(
244 <__A::Error as _serde::de::Error>::duplicate_field(
245 "syncPoints",
246 ),
247 );
248 }
249 m_syncPoints = _serde::__private::Some(
250 match __A::next_value::<
251 [hkbGeneratorSyncInfoSyncPoint; 8usize],
252 >(&mut __map) {
253 _serde::__private::Ok(__val) => __val,
254 _serde::__private::Err(__err) => {
255 return _serde::__private::Err(__err);
256 }
257 },
258 );
259 }
260 1usize => {
261 if _serde::__private::Option::is_some(&m_baseFrequency) {
262 return _serde::__private::Err(
263 <__A::Error as _serde::de::Error>::duplicate_field(
264 "baseFrequency",
265 ),
266 );
267 }
268 m_baseFrequency = _serde::__private::Some(
269 match __A::next_value::<f32>(&mut __map) {
270 _serde::__private::Ok(__val) => __val,
271 _serde::__private::Err(__err) => {
272 return _serde::__private::Err(__err);
273 }
274 },
275 );
276 }
277 2usize => {
278 if _serde::__private::Option::is_some(&m_localTime) {
279 return _serde::__private::Err(
280 <__A::Error as _serde::de::Error>::duplicate_field(
281 "localTime",
282 ),
283 );
284 }
285 m_localTime = _serde::__private::Some(
286 match __A::next_value::<f32>(&mut __map) {
287 _serde::__private::Ok(__val) => __val,
288 _serde::__private::Err(__err) => {
289 return _serde::__private::Err(__err);
290 }
291 },
292 );
293 }
294 3usize => {
295 if _serde::__private::Option::is_some(&m_playbackSpeed) {
296 return _serde::__private::Err(
297 <__A::Error as _serde::de::Error>::duplicate_field(
298 "playbackSpeed",
299 ),
300 );
301 }
302 m_playbackSpeed = _serde::__private::Some(
303 match __A::next_value::<f32>(&mut __map) {
304 _serde::__private::Ok(__val) => __val,
305 _serde::__private::Err(__err) => {
306 return _serde::__private::Err(__err);
307 }
308 },
309 );
310 }
311 4usize => {
312 if _serde::__private::Option::is_some(&m_numSyncPoints) {
313 return _serde::__private::Err(
314 <__A::Error as _serde::de::Error>::duplicate_field(
315 "numSyncPoints",
316 ),
317 );
318 }
319 m_numSyncPoints = _serde::__private::Some(
320 match __A::next_value::<i8>(&mut __map) {
321 _serde::__private::Ok(__val) => __val,
322 _serde::__private::Err(__err) => {
323 return _serde::__private::Err(__err);
324 }
325 },
326 );
327 }
328 5usize => {
329 if _serde::__private::Option::is_some(&m_isCyclic) {
330 return _serde::__private::Err(
331 <__A::Error as _serde::de::Error>::duplicate_field(
332 "isCyclic",
333 ),
334 );
335 }
336 m_isCyclic = _serde::__private::Some(
337 match __A::next_value::<bool>(&mut __map) {
338 _serde::__private::Ok(__val) => __val,
339 _serde::__private::Err(__err) => {
340 return _serde::__private::Err(__err);
341 }
342 },
343 );
344 }
345 6usize => {
346 if _serde::__private::Option::is_some(&m_isMirrored) {
347 return _serde::__private::Err(
348 <__A::Error as _serde::de::Error>::duplicate_field(
349 "isMirrored",
350 ),
351 );
352 }
353 m_isMirrored = _serde::__private::Some(
354 match __A::next_value::<bool>(&mut __map) {
355 _serde::__private::Ok(__val) => __val,
356 _serde::__private::Err(__err) => {
357 return _serde::__private::Err(__err);
358 }
359 },
360 );
361 }
362 7usize => {
363 if _serde::__private::Option::is_some(&m_isAdditive) {
364 return _serde::__private::Err(
365 <__A::Error as _serde::de::Error>::duplicate_field(
366 "isAdditive",
367 ),
368 );
369 }
370 m_isAdditive = _serde::__private::Some(
371 match __A::next_value::<bool>(&mut __map) {
372 _serde::__private::Ok(__val) => __val,
373 _serde::__private::Err(__err) => {
374 return _serde::__private::Err(__err);
375 }
376 },
377 );
378 }
379 _ => {}
380 }
381 }
382 let m_syncPoints = match m_syncPoints {
383 _serde::__private::Some(__field) => __field,
384 _serde::__private::None => {
385 return _serde::__private::Err(
386 <__A::Error as _serde::de::Error>::missing_field(
387 "syncPoints",
388 ),
389 );
390 }
391 };
392 let m_baseFrequency = match m_baseFrequency {
393 _serde::__private::Some(__field) => __field,
394 _serde::__private::None => {
395 return _serde::__private::Err(
396 <__A::Error as _serde::de::Error>::missing_field(
397 "baseFrequency",
398 ),
399 );
400 }
401 };
402 let m_localTime = match m_localTime {
403 _serde::__private::Some(__field) => __field,
404 _serde::__private::None => {
405 return _serde::__private::Err(
406 <__A::Error as _serde::de::Error>::missing_field(
407 "localTime",
408 ),
409 );
410 }
411 };
412 let m_playbackSpeed = match m_playbackSpeed {
413 _serde::__private::Some(__field) => __field,
414 _serde::__private::None => {
415 return _serde::__private::Err(
416 <__A::Error as _serde::de::Error>::missing_field(
417 "playbackSpeed",
418 ),
419 );
420 }
421 };
422 let m_numSyncPoints = match m_numSyncPoints {
423 _serde::__private::Some(__field) => __field,
424 _serde::__private::None => {
425 return _serde::__private::Err(
426 <__A::Error as _serde::de::Error>::missing_field(
427 "numSyncPoints",
428 ),
429 );
430 }
431 };
432 let m_isCyclic = match m_isCyclic {
433 _serde::__private::Some(__field) => __field,
434 _serde::__private::None => {
435 return _serde::__private::Err(
436 <__A::Error as _serde::de::Error>::missing_field("isCyclic"),
437 );
438 }
439 };
440 let m_isMirrored = match m_isMirrored {
441 _serde::__private::Some(__field) => __field,
442 _serde::__private::None => {
443 return _serde::__private::Err(
444 <__A::Error as _serde::de::Error>::missing_field(
445 "isMirrored",
446 ),
447 );
448 }
449 };
450 let m_isAdditive = match m_isAdditive {
451 _serde::__private::Some(__field) => __field,
452 _serde::__private::None => {
453 return _serde::__private::Err(
454 <__A::Error as _serde::de::Error>::missing_field(
455 "isAdditive",
456 ),
457 );
458 }
459 };
460 _serde::__private::Ok(hkbGeneratorSyncInfo {
461 __ptr,
462 m_syncPoints,
463 m_baseFrequency,
464 m_localTime,
465 m_playbackSpeed,
466 m_numSyncPoints,
467 m_isCyclic,
468 m_isMirrored,
469 m_isAdditive,
470 })
471 }
472 #[allow(clippy::manual_unwrap_or_default)]
473 fn visit_struct<__A>(
474 self,
475 mut __map: __A,
476 ) -> _serde::__private::Result<Self::Value, __A::Error>
477 where
478 __A: _serde::de::MapAccess<'de>,
479 {
480 let mut m_syncPoints: _serde::__private::Option<
481 [hkbGeneratorSyncInfoSyncPoint; 8usize],
482 > = _serde::__private::None;
483 let mut m_baseFrequency: _serde::__private::Option<f32> = _serde::__private::None;
484 let mut m_localTime: _serde::__private::Option<f32> = _serde::__private::None;
485 let mut m_playbackSpeed: _serde::__private::Option<f32> = _serde::__private::None;
486 let mut m_numSyncPoints: _serde::__private::Option<i8> = _serde::__private::None;
487 let mut m_isCyclic: _serde::__private::Option<bool> = _serde::__private::None;
488 let mut m_isMirrored: _serde::__private::Option<bool> = _serde::__private::None;
489 let mut m_isAdditive: _serde::__private::Option<bool> = _serde::__private::None;
490 while let _serde::__private::Some(__key) = {
491 __A::next_key::<__Field>(&mut __map)?
492 } {
493 match __key {
494 __Field::m_syncPoints => {
495 #[cfg(
496 any(feature = "strict", feature = "ignore_duplicates")
497 )]
498 if _serde::__private::Option::is_some(&m_syncPoints) {
499 #[cfg(feature = "ignore_duplicates")]
500 {
501 __A::skip_value(&mut __map)?;
502 continue;
503 }
504 #[cfg(feature = "strict")]
505 return _serde::__private::Err(
506 <__A::Error as _serde::de::Error>::duplicate_field(
507 "syncPoints",
508 ),
509 );
510 }
511 m_syncPoints = _serde::__private::Some(
512 match __A::next_value::<
513 [hkbGeneratorSyncInfoSyncPoint; 8usize],
514 >(&mut __map) {
515 _serde::__private::Ok(__val) => __val,
516 _serde::__private::Err(__err) => {
517 return _serde::__private::Err(__err);
518 }
519 },
520 );
521 }
522 __Field::m_baseFrequency => {
523 #[cfg(
524 any(feature = "strict", feature = "ignore_duplicates")
525 )]
526 if _serde::__private::Option::is_some(&m_baseFrequency) {
527 #[cfg(feature = "ignore_duplicates")]
528 {
529 __A::skip_value(&mut __map)?;
530 continue;
531 }
532 #[cfg(feature = "strict")]
533 return _serde::__private::Err(
534 <__A::Error as _serde::de::Error>::duplicate_field(
535 "baseFrequency",
536 ),
537 );
538 }
539 m_baseFrequency = _serde::__private::Some(
540 match __A::next_value::<f32>(&mut __map) {
541 _serde::__private::Ok(__val) => __val,
542 _serde::__private::Err(__err) => {
543 return _serde::__private::Err(__err);
544 }
545 },
546 );
547 }
548 __Field::m_localTime => {
549 #[cfg(
550 any(feature = "strict", feature = "ignore_duplicates")
551 )]
552 if _serde::__private::Option::is_some(&m_localTime) {
553 #[cfg(feature = "ignore_duplicates")]
554 {
555 __A::skip_value(&mut __map)?;
556 continue;
557 }
558 #[cfg(feature = "strict")]
559 return _serde::__private::Err(
560 <__A::Error as _serde::de::Error>::duplicate_field(
561 "localTime",
562 ),
563 );
564 }
565 m_localTime = _serde::__private::Some(
566 match __A::next_value::<f32>(&mut __map) {
567 _serde::__private::Ok(__val) => __val,
568 _serde::__private::Err(__err) => {
569 return _serde::__private::Err(__err);
570 }
571 },
572 );
573 }
574 __Field::m_playbackSpeed => {
575 #[cfg(
576 any(feature = "strict", feature = "ignore_duplicates")
577 )]
578 if _serde::__private::Option::is_some(&m_playbackSpeed) {
579 #[cfg(feature = "ignore_duplicates")]
580 {
581 __A::skip_value(&mut __map)?;
582 continue;
583 }
584 #[cfg(feature = "strict")]
585 return _serde::__private::Err(
586 <__A::Error as _serde::de::Error>::duplicate_field(
587 "playbackSpeed",
588 ),
589 );
590 }
591 m_playbackSpeed = _serde::__private::Some(
592 match __A::next_value::<f32>(&mut __map) {
593 _serde::__private::Ok(__val) => __val,
594 _serde::__private::Err(__err) => {
595 return _serde::__private::Err(__err);
596 }
597 },
598 );
599 }
600 __Field::m_numSyncPoints => {
601 #[cfg(
602 any(feature = "strict", feature = "ignore_duplicates")
603 )]
604 if _serde::__private::Option::is_some(&m_numSyncPoints) {
605 #[cfg(feature = "ignore_duplicates")]
606 {
607 __A::skip_value(&mut __map)?;
608 continue;
609 }
610 #[cfg(feature = "strict")]
611 return _serde::__private::Err(
612 <__A::Error as _serde::de::Error>::duplicate_field(
613 "numSyncPoints",
614 ),
615 );
616 }
617 m_numSyncPoints = _serde::__private::Some(
618 match __A::next_value::<i8>(&mut __map) {
619 _serde::__private::Ok(__val) => __val,
620 _serde::__private::Err(__err) => {
621 return _serde::__private::Err(__err);
622 }
623 },
624 );
625 }
626 __Field::m_isCyclic => {
627 #[cfg(
628 any(feature = "strict", feature = "ignore_duplicates")
629 )]
630 if _serde::__private::Option::is_some(&m_isCyclic) {
631 #[cfg(feature = "ignore_duplicates")]
632 {
633 __A::skip_value(&mut __map)?;
634 continue;
635 }
636 #[cfg(feature = "strict")]
637 return _serde::__private::Err(
638 <__A::Error as _serde::de::Error>::duplicate_field(
639 "isCyclic",
640 ),
641 );
642 }
643 m_isCyclic = _serde::__private::Some(
644 match __A::next_value::<bool>(&mut __map) {
645 _serde::__private::Ok(__val) => __val,
646 _serde::__private::Err(__err) => {
647 return _serde::__private::Err(__err);
648 }
649 },
650 );
651 }
652 __Field::m_isMirrored => {
653 #[cfg(
654 any(feature = "strict", feature = "ignore_duplicates")
655 )]
656 if _serde::__private::Option::is_some(&m_isMirrored) {
657 #[cfg(feature = "ignore_duplicates")]
658 {
659 __A::skip_value(&mut __map)?;
660 continue;
661 }
662 #[cfg(feature = "strict")]
663 return _serde::__private::Err(
664 <__A::Error as _serde::de::Error>::duplicate_field(
665 "isMirrored",
666 ),
667 );
668 }
669 m_isMirrored = _serde::__private::Some(
670 match __A::next_value::<bool>(&mut __map) {
671 _serde::__private::Ok(__val) => __val,
672 _serde::__private::Err(__err) => {
673 return _serde::__private::Err(__err);
674 }
675 },
676 );
677 }
678 __Field::m_isAdditive => {
679 #[cfg(
680 any(feature = "strict", feature = "ignore_duplicates")
681 )]
682 if _serde::__private::Option::is_some(&m_isAdditive) {
683 #[cfg(feature = "ignore_duplicates")]
684 {
685 __A::skip_value(&mut __map)?;
686 continue;
687 }
688 #[cfg(feature = "strict")]
689 return _serde::__private::Err(
690 <__A::Error as _serde::de::Error>::duplicate_field(
691 "isAdditive",
692 ),
693 );
694 }
695 m_isAdditive = _serde::__private::Some(
696 match __A::next_value::<bool>(&mut __map) {
697 _serde::__private::Ok(__val) => __val,
698 _serde::__private::Err(__err) => {
699 return _serde::__private::Err(__err);
700 }
701 },
702 );
703 }
704 _ => __A::skip_value(&mut __map)?,
705 }
706 }
707 let m_syncPoints = match m_syncPoints {
708 _serde::__private::Some(__field) => __field,
709 _serde::__private::None => {
710 #[cfg(feature = "strict")]
711 return _serde::__private::Err(
712 <__A::Error as _serde::de::Error>::missing_field(
713 "syncPoints",
714 ),
715 );
716 #[cfg(not(feature = "strict"))] Default::default()
717 }
718 };
719 let m_baseFrequency = match m_baseFrequency {
720 _serde::__private::Some(__field) => __field,
721 _serde::__private::None => {
722 #[cfg(feature = "strict")]
723 return _serde::__private::Err(
724 <__A::Error as _serde::de::Error>::missing_field(
725 "baseFrequency",
726 ),
727 );
728 #[cfg(not(feature = "strict"))] Default::default()
729 }
730 };
731 let m_localTime = match m_localTime {
732 _serde::__private::Some(__field) => __field,
733 _serde::__private::None => {
734 #[cfg(feature = "strict")]
735 return _serde::__private::Err(
736 <__A::Error as _serde::de::Error>::missing_field(
737 "localTime",
738 ),
739 );
740 #[cfg(not(feature = "strict"))] Default::default()
741 }
742 };
743 let m_playbackSpeed = match m_playbackSpeed {
744 _serde::__private::Some(__field) => __field,
745 _serde::__private::None => {
746 #[cfg(feature = "strict")]
747 return _serde::__private::Err(
748 <__A::Error as _serde::de::Error>::missing_field(
749 "playbackSpeed",
750 ),
751 );
752 #[cfg(not(feature = "strict"))] Default::default()
753 }
754 };
755 let m_numSyncPoints = match m_numSyncPoints {
756 _serde::__private::Some(__field) => __field,
757 _serde::__private::None => {
758 #[cfg(feature = "strict")]
759 return _serde::__private::Err(
760 <__A::Error as _serde::de::Error>::missing_field(
761 "numSyncPoints",
762 ),
763 );
764 #[cfg(not(feature = "strict"))] Default::default()
765 }
766 };
767 let m_isCyclic = match m_isCyclic {
768 _serde::__private::Some(__field) => __field,
769 _serde::__private::None => {
770 #[cfg(feature = "strict")]
771 return _serde::__private::Err(
772 <__A::Error as _serde::de::Error>::missing_field("isCyclic"),
773 );
774 #[cfg(not(feature = "strict"))] Default::default()
775 }
776 };
777 let m_isMirrored = match m_isMirrored {
778 _serde::__private::Some(__field) => __field,
779 _serde::__private::None => {
780 #[cfg(feature = "strict")]
781 return _serde::__private::Err(
782 <__A::Error as _serde::de::Error>::missing_field(
783 "isMirrored",
784 ),
785 );
786 #[cfg(not(feature = "strict"))] Default::default()
787 }
788 };
789 let m_isAdditive = match m_isAdditive {
790 _serde::__private::Some(__field) => __field,
791 _serde::__private::None => {
792 #[cfg(feature = "strict")]
793 return _serde::__private::Err(
794 <__A::Error as _serde::de::Error>::missing_field(
795 "isAdditive",
796 ),
797 );
798 #[cfg(not(feature = "strict"))] Default::default()
799 }
800 };
801 let __ptr = __A::class_ptr(&mut __map);
802 _serde::__private::Ok(hkbGeneratorSyncInfo {
803 __ptr,
804 m_syncPoints,
805 m_baseFrequency,
806 m_localTime,
807 m_playbackSpeed,
808 m_numSyncPoints,
809 m_isCyclic,
810 m_isMirrored,
811 m_isAdditive,
812 })
813 }
814 }
815 const FIELDS: &[&str] = &[
816 "syncPoints",
817 "baseFrequency",
818 "localTime",
819 "playbackSpeed",
820 "numSyncPoints",
821 "isCyclic",
822 "isMirrored",
823 "isAdditive",
824 ];
825 _serde::Deserializer::deserialize_struct(
826 deserializer,
827 "hkbGeneratorSyncInfo",
828 FIELDS,
829 __hkbGeneratorSyncInfoVisitor {
830 marker: _serde::__private::PhantomData::<hkbGeneratorSyncInfo>,
831 lifetime: _serde::__private::PhantomData,
832 },
833 )
834 }
835 }
836};