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 BSSynchronizedClipGenerator<'a> {
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 #[cfg_attr(feature = "serde", serde(borrow))]
30 pub parent: hkbGenerator<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "pClipGenerator"))]
37 #[cfg_attr(feature = "serde", serde(rename = "pClipGenerator"))]
38 pub m_pClipGenerator: Pointer,
39 #[cfg_attr(feature = "serde", serde(borrow))]
44 #[cfg_attr(feature = "json_schema", schemars(rename = "SyncAnimPrefix"))]
45 #[cfg_attr(feature = "serde", serde(rename = "SyncAnimPrefix"))]
46 pub m_SyncAnimPrefix: CString<'a>,
47 #[cfg_attr(
52 feature = "json_schema",
53 schemars(rename = "bSyncClipIgnoreMarkPlacement")
54 )]
55 #[cfg_attr(feature = "serde", serde(rename = "bSyncClipIgnoreMarkPlacement"))]
56 pub m_bSyncClipIgnoreMarkPlacement: bool,
57 #[cfg_attr(feature = "json_schema", schemars(rename = "fGetToMarkTime"))]
62 #[cfg_attr(feature = "serde", serde(rename = "fGetToMarkTime"))]
63 pub m_fGetToMarkTime: f32,
64 #[cfg_attr(feature = "json_schema", schemars(rename = "fMarkErrorThreshold"))]
69 #[cfg_attr(feature = "serde", serde(rename = "fMarkErrorThreshold"))]
70 pub m_fMarkErrorThreshold: f32,
71 #[cfg_attr(feature = "json_schema", schemars(rename = "bLeadCharacter"))]
76 #[cfg_attr(feature = "serde", serde(rename = "bLeadCharacter"))]
77 pub m_bLeadCharacter: bool,
78 #[cfg_attr(feature = "json_schema", schemars(rename = "bReorientSupportChar"))]
83 #[cfg_attr(feature = "serde", serde(rename = "bReorientSupportChar"))]
84 pub m_bReorientSupportChar: bool,
85 #[cfg_attr(feature = "json_schema", schemars(rename = "bApplyMotionFromRoot"))]
90 #[cfg_attr(feature = "serde", serde(rename = "bApplyMotionFromRoot"))]
91 pub m_bApplyMotionFromRoot: bool,
92 #[cfg_attr(feature = "json_schema", schemars(rename = "pSyncScene"))]
98 #[cfg_attr(feature = "serde", serde(rename = "pSyncScene"))]
99 pub m_pSyncScene: Pointer,
100 #[cfg_attr(feature = "json_schema", schemars(rename = "StartMarkWS"))]
106 #[cfg_attr(feature = "serde", serde(rename = "StartMarkWS"))]
107 pub m_StartMarkWS: QsTransform,
108 #[cfg_attr(feature = "json_schema", schemars(rename = "EndMarkWS"))]
114 #[cfg_attr(feature = "serde", serde(rename = "EndMarkWS"))]
115 pub m_EndMarkWS: QsTransform,
116 #[cfg_attr(feature = "json_schema", schemars(rename = "StartMarkMS"))]
122 #[cfg_attr(feature = "serde", serde(rename = "StartMarkMS"))]
123 pub m_StartMarkMS: QsTransform,
124 #[cfg_attr(feature = "json_schema", schemars(rename = "fCurrentLerp"))]
130 #[cfg_attr(feature = "serde", serde(rename = "fCurrentLerp"))]
131 pub m_fCurrentLerp: f32,
132 #[cfg_attr(feature = "json_schema", schemars(rename = "pLocalSyncBinding"))]
138 #[cfg_attr(feature = "serde", serde(rename = "pLocalSyncBinding"))]
139 pub m_pLocalSyncBinding: Pointer,
140 #[cfg_attr(feature = "json_schema", schemars(rename = "pEventMap"))]
146 #[cfg_attr(feature = "serde", serde(rename = "pEventMap"))]
147 pub m_pEventMap: Pointer,
148 #[cfg_attr(feature = "json_schema", schemars(rename = "sAnimationBindingIndex"))]
153 #[cfg_attr(feature = "serde", serde(rename = "sAnimationBindingIndex"))]
154 pub m_sAnimationBindingIndex: i16,
155 #[cfg_attr(feature = "json_schema", schemars(rename = "bAtMark"))]
161 #[cfg_attr(feature = "serde", serde(rename = "bAtMark"))]
162 pub m_bAtMark: bool,
163 #[cfg_attr(feature = "json_schema", schemars(rename = "bAllCharactersInScene"))]
169 #[cfg_attr(feature = "serde", serde(rename = "bAllCharactersInScene"))]
170 pub m_bAllCharactersInScene: bool,
171 #[cfg_attr(feature = "json_schema", schemars(rename = "bAllCharactersAtMarks"))]
177 #[cfg_attr(feature = "serde", serde(rename = "bAllCharactersAtMarks"))]
178 pub m_bAllCharactersAtMarks: bool,
179}
180const _: () = {
181 use havok_serde as _serde;
182 impl<'a> _serde::HavokClass for BSSynchronizedClipGenerator<'a> {
183 #[inline]
184 fn name(&self) -> &'static str {
185 "BSSynchronizedClipGenerator"
186 }
187 #[inline]
188 fn signature(&self) -> _serde::__private::Signature {
189 _serde::__private::Signature::new(0xd83bea64)
190 }
191 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
192 fn deps_indexes(&self) -> Vec<usize> {
193 let mut v = Vec::new();
194 v.push(self.parent.parent.parent.m_variableBindingSet.get());
195 v.push(self.m_pClipGenerator.get());
196 v.push(self.m_pSyncScene.get());
197 v.push(self.m_pLocalSyncBinding.get());
198 v.push(self.m_pEventMap.get());
199 v
200 }
201 }
202 impl<'a> _serde::Serialize for BSSynchronizedClipGenerator<'a> {
203 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
204 where
205 S: _serde::ser::Serializer,
206 {
207 let class_meta = self
208 .__ptr
209 .map(|name| (name, _serde::__private::Signature::new(0xd83bea64)));
210 let mut serializer = __serializer
211 .serialize_struct(
212 "BSSynchronizedClipGenerator",
213 class_meta,
214 (256u64, 304u64),
215 )?;
216 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
217 serializer
218 .skip_field(
219 "memSizeAndFlags",
220 &self.parent.parent.parent.parent.m_memSizeAndFlags,
221 )?;
222 serializer
223 .skip_field(
224 "referenceCount",
225 &self.parent.parent.parent.parent.m_referenceCount,
226 )?;
227 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
228 serializer
229 .serialize_field(
230 "variableBindingSet",
231 &self.parent.parent.parent.m_variableBindingSet,
232 )?;
233 serializer
234 .skip_array_field(
235 "cachedBindables",
236 &self.parent.parent.parent.m_cachedBindables,
237 TypeSize::NonPtr,
238 )?;
239 serializer
240 .skip_field(
241 "areBindablesCached",
242 &self.parent.parent.parent.m_areBindablesCached,
243 )?;
244 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
245 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
246 serializer.serialize_field("name", &self.parent.parent.m_name)?;
247 serializer.skip_field("id", &self.parent.parent.m_id)?;
248 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
249 serializer
250 .skip_fixed_array_field(
251 "padNode",
252 self.parent.parent.m_padNode.as_slice(),
253 TypeSize::NonPtr,
254 )?;
255 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
256 serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 8usize].as_slice())?;
257 serializer.serialize_field("pClipGenerator", &self.m_pClipGenerator)?;
258 serializer.serialize_field("SyncAnimPrefix", &self.m_SyncAnimPrefix)?;
259 serializer
260 .serialize_field(
261 "bSyncClipIgnoreMarkPlacement",
262 &self.m_bSyncClipIgnoreMarkPlacement,
263 )?;
264 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
265 serializer.serialize_field("fGetToMarkTime", &self.m_fGetToMarkTime)?;
266 serializer
267 .serialize_field("fMarkErrorThreshold", &self.m_fMarkErrorThreshold)?;
268 serializer.serialize_field("bLeadCharacter", &self.m_bLeadCharacter)?;
269 serializer
270 .serialize_field("bReorientSupportChar", &self.m_bReorientSupportChar)?;
271 serializer
272 .serialize_field("bApplyMotionFromRoot", &self.m_bApplyMotionFromRoot)?;
273 serializer.pad_field([0u8; 1usize].as_slice(), [0u8; 1usize].as_slice())?;
274 serializer.skip_field("pSyncScene", &self.m_pSyncScene)?;
275 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
276 serializer.skip_field("StartMarkWS", &self.m_StartMarkWS)?;
277 serializer.skip_field("EndMarkWS", &self.m_EndMarkWS)?;
278 serializer.skip_field("StartMarkMS", &self.m_StartMarkMS)?;
279 serializer.skip_field("fCurrentLerp", &self.m_fCurrentLerp)?;
280 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
281 serializer.skip_field("pLocalSyncBinding", &self.m_pLocalSyncBinding)?;
282 serializer.skip_field("pEventMap", &self.m_pEventMap)?;
283 serializer
284 .serialize_field(
285 "sAnimationBindingIndex",
286 &self.m_sAnimationBindingIndex,
287 )?;
288 serializer.skip_field("bAtMark", &self.m_bAtMark)?;
289 serializer
290 .skip_field("bAllCharactersInScene", &self.m_bAllCharactersInScene)?;
291 serializer
292 .skip_field("bAllCharactersAtMarks", &self.m_bAllCharactersAtMarks)?;
293 serializer.pad_field([0u8; 15usize].as_slice(), [0u8; 3usize].as_slice())?;
294 serializer.end()
295 }
296 }
297};
298#[doc(hidden)]
299#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
300const _: () = {
301 use havok_serde as _serde;
302 #[automatically_derived]
303 impl<'de> _serde::Deserialize<'de> for BSSynchronizedClipGenerator<'de> {
304 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
305 where
306 __D: _serde::Deserializer<'de>,
307 {
308 #[allow(non_camel_case_types)]
309 enum __Field {
310 m_variableBindingSet,
311 m_userData,
312 m_name,
313 m_pClipGenerator,
314 m_SyncAnimPrefix,
315 m_bSyncClipIgnoreMarkPlacement,
316 m_fGetToMarkTime,
317 m_fMarkErrorThreshold,
318 m_bLeadCharacter,
319 m_bReorientSupportChar,
320 m_bApplyMotionFromRoot,
321 m_sAnimationBindingIndex,
322 __ignore,
323 }
324 struct __FieldVisitor;
325 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
326 type Value = __Field;
327 fn expecting(
328 &self,
329 __formatter: &mut core::fmt::Formatter,
330 ) -> core::fmt::Result {
331 core::fmt::Formatter::write_str(__formatter, "field identifier")
332 }
333 #[allow(clippy::match_single_binding)]
335 #[allow(clippy::reversed_empty_ranges)]
336 #[allow(clippy::single_match)]
337 fn visit_key<__E>(
338 self,
339 __value: &str,
340 ) -> core::result::Result<Self::Value, __E>
341 where
342 __E: _serde::de::Error,
343 {
344 match __value {
345 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
346 "userData" => Ok(__Field::m_userData),
347 "name" => Ok(__Field::m_name),
348 "pClipGenerator" => Ok(__Field::m_pClipGenerator),
349 "SyncAnimPrefix" => Ok(__Field::m_SyncAnimPrefix),
350 "bSyncClipIgnoreMarkPlacement" => {
351 Ok(__Field::m_bSyncClipIgnoreMarkPlacement)
352 }
353 "fGetToMarkTime" => Ok(__Field::m_fGetToMarkTime),
354 "fMarkErrorThreshold" => Ok(__Field::m_fMarkErrorThreshold),
355 "bLeadCharacter" => Ok(__Field::m_bLeadCharacter),
356 "bReorientSupportChar" => Ok(__Field::m_bReorientSupportChar),
357 "bApplyMotionFromRoot" => Ok(__Field::m_bApplyMotionFromRoot),
358 "sAnimationBindingIndex" => Ok(__Field::m_sAnimationBindingIndex),
359 _ => Ok(__Field::__ignore),
360 }
361 }
362 }
363 impl<'de> _serde::Deserialize<'de> for __Field {
364 #[inline]
365 fn deserialize<__D>(
366 __deserializer: __D,
367 ) -> core::result::Result<Self, __D::Error>
368 where
369 __D: _serde::Deserializer<'de>,
370 {
371 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
372 }
373 }
374 struct __BSSynchronizedClipGeneratorVisitor<'de> {
375 marker: _serde::__private::PhantomData<BSSynchronizedClipGenerator<'de>>,
376 lifetime: _serde::__private::PhantomData<&'de ()>,
377 }
378 #[allow(clippy::match_single_binding)]
379 #[allow(clippy::reversed_empty_ranges)]
380 #[allow(clippy::single_match)]
381 impl<'de> _serde::de::Visitor<'de>
382 for __BSSynchronizedClipGeneratorVisitor<'de> {
383 type Value = BSSynchronizedClipGenerator<'de>;
384 fn expecting(
385 &self,
386 __formatter: &mut core::fmt::Formatter,
387 ) -> core::fmt::Result {
388 core::fmt::Formatter::write_str(
389 __formatter,
390 "struct BSSynchronizedClipGenerator",
391 )
392 }
393 fn visit_struct_for_bytes<__A>(
394 self,
395 mut __map: __A,
396 ) -> _serde::__private::Result<Self::Value, __A::Error>
397 where
398 __A: _serde::de::MapAccess<'de>,
399 {
400 let __ptr = __A::class_ptr(&mut __map);
401 let parent = __A::parent_value(&mut __map)?;
402 let mut m_pClipGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
403 let mut m_SyncAnimPrefix: _serde::__private::Option<CString<'de>> = _serde::__private::None;
404 let mut m_bSyncClipIgnoreMarkPlacement: _serde::__private::Option<
405 bool,
406 > = _serde::__private::None;
407 let mut m_fGetToMarkTime: _serde::__private::Option<f32> = _serde::__private::None;
408 let mut m_fMarkErrorThreshold: _serde::__private::Option<f32> = _serde::__private::None;
409 let mut m_bLeadCharacter: _serde::__private::Option<bool> = _serde::__private::None;
410 let mut m_bReorientSupportChar: _serde::__private::Option<bool> = _serde::__private::None;
411 let mut m_bApplyMotionFromRoot: _serde::__private::Option<bool> = _serde::__private::None;
412 let mut m_pSyncScene: _serde::__private::Option<Pointer> = _serde::__private::None;
413 let mut m_StartMarkWS: _serde::__private::Option<QsTransform> = _serde::__private::None;
414 let mut m_EndMarkWS: _serde::__private::Option<QsTransform> = _serde::__private::None;
415 let mut m_StartMarkMS: _serde::__private::Option<QsTransform> = _serde::__private::None;
416 let mut m_fCurrentLerp: _serde::__private::Option<f32> = _serde::__private::None;
417 let mut m_pLocalSyncBinding: _serde::__private::Option<Pointer> = _serde::__private::None;
418 let mut m_pEventMap: _serde::__private::Option<Pointer> = _serde::__private::None;
419 let mut m_sAnimationBindingIndex: _serde::__private::Option<i16> = _serde::__private::None;
420 let mut m_bAtMark: _serde::__private::Option<bool> = _serde::__private::None;
421 let mut m_bAllCharactersInScene: _serde::__private::Option<bool> = _serde::__private::None;
422 let mut m_bAllCharactersAtMarks: _serde::__private::Option<bool> = _serde::__private::None;
423 for i in 0..19usize {
424 match i {
425 0usize => {
426 if _serde::__private::Option::is_some(&m_pClipGenerator) {
427 return _serde::__private::Err(
428 <__A::Error as _serde::de::Error>::duplicate_field(
429 "pClipGenerator",
430 ),
431 );
432 }
433 __A::pad(&mut __map, 8usize, 8usize)?;
434 m_pClipGenerator = _serde::__private::Some(
435 match __A::next_value::<Pointer>(&mut __map) {
436 _serde::__private::Ok(__val) => __val,
437 _serde::__private::Err(__err) => {
438 return _serde::__private::Err(__err);
439 }
440 },
441 );
442 }
443 1usize => {
444 if _serde::__private::Option::is_some(&m_SyncAnimPrefix) {
445 return _serde::__private::Err(
446 <__A::Error as _serde::de::Error>::duplicate_field(
447 "SyncAnimPrefix",
448 ),
449 );
450 }
451 m_SyncAnimPrefix = _serde::__private::Some(
452 match __A::next_value::<CString<'de>>(&mut __map) {
453 _serde::__private::Ok(__val) => __val,
454 _serde::__private::Err(__err) => {
455 return _serde::__private::Err(__err);
456 }
457 },
458 );
459 }
460 2usize => {
461 if _serde::__private::Option::is_some(
462 &m_bSyncClipIgnoreMarkPlacement,
463 ) {
464 return _serde::__private::Err(
465 <__A::Error as _serde::de::Error>::duplicate_field(
466 "bSyncClipIgnoreMarkPlacement",
467 ),
468 );
469 }
470 m_bSyncClipIgnoreMarkPlacement = _serde::__private::Some(
471 match __A::next_value::<bool>(&mut __map) {
472 _serde::__private::Ok(__val) => __val,
473 _serde::__private::Err(__err) => {
474 return _serde::__private::Err(__err);
475 }
476 },
477 );
478 }
479 3usize => {
480 if _serde::__private::Option::is_some(&m_fGetToMarkTime) {
481 return _serde::__private::Err(
482 <__A::Error as _serde::de::Error>::duplicate_field(
483 "fGetToMarkTime",
484 ),
485 );
486 }
487 __A::pad(&mut __map, 3usize, 3usize)?;
488 m_fGetToMarkTime = _serde::__private::Some(
489 match __A::next_value::<f32>(&mut __map) {
490 _serde::__private::Ok(__val) => __val,
491 _serde::__private::Err(__err) => {
492 return _serde::__private::Err(__err);
493 }
494 },
495 );
496 }
497 4usize => {
498 if _serde::__private::Option::is_some(
499 &m_fMarkErrorThreshold,
500 ) {
501 return _serde::__private::Err(
502 <__A::Error as _serde::de::Error>::duplicate_field(
503 "fMarkErrorThreshold",
504 ),
505 );
506 }
507 m_fMarkErrorThreshold = _serde::__private::Some(
508 match __A::next_value::<f32>(&mut __map) {
509 _serde::__private::Ok(__val) => __val,
510 _serde::__private::Err(__err) => {
511 return _serde::__private::Err(__err);
512 }
513 },
514 );
515 }
516 5usize => {
517 if _serde::__private::Option::is_some(&m_bLeadCharacter) {
518 return _serde::__private::Err(
519 <__A::Error as _serde::de::Error>::duplicate_field(
520 "bLeadCharacter",
521 ),
522 );
523 }
524 m_bLeadCharacter = _serde::__private::Some(
525 match __A::next_value::<bool>(&mut __map) {
526 _serde::__private::Ok(__val) => __val,
527 _serde::__private::Err(__err) => {
528 return _serde::__private::Err(__err);
529 }
530 },
531 );
532 }
533 6usize => {
534 if _serde::__private::Option::is_some(
535 &m_bReorientSupportChar,
536 ) {
537 return _serde::__private::Err(
538 <__A::Error as _serde::de::Error>::duplicate_field(
539 "bReorientSupportChar",
540 ),
541 );
542 }
543 m_bReorientSupportChar = _serde::__private::Some(
544 match __A::next_value::<bool>(&mut __map) {
545 _serde::__private::Ok(__val) => __val,
546 _serde::__private::Err(__err) => {
547 return _serde::__private::Err(__err);
548 }
549 },
550 );
551 }
552 7usize => {
553 if _serde::__private::Option::is_some(
554 &m_bApplyMotionFromRoot,
555 ) {
556 return _serde::__private::Err(
557 <__A::Error as _serde::de::Error>::duplicate_field(
558 "bApplyMotionFromRoot",
559 ),
560 );
561 }
562 m_bApplyMotionFromRoot = _serde::__private::Some(
563 match __A::next_value::<bool>(&mut __map) {
564 _serde::__private::Ok(__val) => __val,
565 _serde::__private::Err(__err) => {
566 return _serde::__private::Err(__err);
567 }
568 },
569 );
570 }
571 8usize => {
572 if _serde::__private::Option::is_some(&m_pSyncScene) {
573 return _serde::__private::Err(
574 <__A::Error as _serde::de::Error>::duplicate_field(
575 "pSyncScene",
576 ),
577 );
578 }
579 __A::pad(&mut __map, 1usize, 1usize)?;
580 m_pSyncScene = _serde::__private::Some(
581 match __A::next_value::<Pointer>(&mut __map) {
582 _serde::__private::Ok(__val) => __val,
583 _serde::__private::Err(__err) => {
584 return _serde::__private::Err(__err);
585 }
586 },
587 );
588 }
589 9usize => {
590 if _serde::__private::Option::is_some(&m_StartMarkWS) {
591 return _serde::__private::Err(
592 <__A::Error as _serde::de::Error>::duplicate_field(
593 "StartMarkWS",
594 ),
595 );
596 }
597 __A::pad(&mut __map, 4usize, 8usize)?;
598 m_StartMarkWS = _serde::__private::Some(
599 match __A::next_value::<QsTransform>(&mut __map) {
600 _serde::__private::Ok(__val) => __val,
601 _serde::__private::Err(__err) => {
602 return _serde::__private::Err(__err);
603 }
604 },
605 );
606 }
607 10usize => {
608 if _serde::__private::Option::is_some(&m_EndMarkWS) {
609 return _serde::__private::Err(
610 <__A::Error as _serde::de::Error>::duplicate_field(
611 "EndMarkWS",
612 ),
613 );
614 }
615 m_EndMarkWS = _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 11usize => {
625 if _serde::__private::Option::is_some(&m_StartMarkMS) {
626 return _serde::__private::Err(
627 <__A::Error as _serde::de::Error>::duplicate_field(
628 "StartMarkMS",
629 ),
630 );
631 }
632 m_StartMarkMS = _serde::__private::Some(
633 match __A::next_value::<QsTransform>(&mut __map) {
634 _serde::__private::Ok(__val) => __val,
635 _serde::__private::Err(__err) => {
636 return _serde::__private::Err(__err);
637 }
638 },
639 );
640 }
641 12usize => {
642 if _serde::__private::Option::is_some(&m_fCurrentLerp) {
643 return _serde::__private::Err(
644 <__A::Error as _serde::de::Error>::duplicate_field(
645 "fCurrentLerp",
646 ),
647 );
648 }
649 m_fCurrentLerp = _serde::__private::Some(
650 match __A::next_value::<f32>(&mut __map) {
651 _serde::__private::Ok(__val) => __val,
652 _serde::__private::Err(__err) => {
653 return _serde::__private::Err(__err);
654 }
655 },
656 );
657 }
658 13usize => {
659 if _serde::__private::Option::is_some(
660 &m_pLocalSyncBinding,
661 ) {
662 return _serde::__private::Err(
663 <__A::Error as _serde::de::Error>::duplicate_field(
664 "pLocalSyncBinding",
665 ),
666 );
667 }
668 __A::pad(&mut __map, 0usize, 4usize)?;
669 m_pLocalSyncBinding = _serde::__private::Some(
670 match __A::next_value::<Pointer>(&mut __map) {
671 _serde::__private::Ok(__val) => __val,
672 _serde::__private::Err(__err) => {
673 return _serde::__private::Err(__err);
674 }
675 },
676 );
677 }
678 14usize => {
679 if _serde::__private::Option::is_some(&m_pEventMap) {
680 return _serde::__private::Err(
681 <__A::Error as _serde::de::Error>::duplicate_field(
682 "pEventMap",
683 ),
684 );
685 }
686 m_pEventMap = _serde::__private::Some(
687 match __A::next_value::<Pointer>(&mut __map) {
688 _serde::__private::Ok(__val) => __val,
689 _serde::__private::Err(__err) => {
690 return _serde::__private::Err(__err);
691 }
692 },
693 );
694 }
695 15usize => {
696 if _serde::__private::Option::is_some(
697 &m_sAnimationBindingIndex,
698 ) {
699 return _serde::__private::Err(
700 <__A::Error as _serde::de::Error>::duplicate_field(
701 "sAnimationBindingIndex",
702 ),
703 );
704 }
705 m_sAnimationBindingIndex = _serde::__private::Some(
706 match __A::next_value::<i16>(&mut __map) {
707 _serde::__private::Ok(__val) => __val,
708 _serde::__private::Err(__err) => {
709 return _serde::__private::Err(__err);
710 }
711 },
712 );
713 }
714 16usize => {
715 if _serde::__private::Option::is_some(&m_bAtMark) {
716 return _serde::__private::Err(
717 <__A::Error as _serde::de::Error>::duplicate_field(
718 "bAtMark",
719 ),
720 );
721 }
722 m_bAtMark = _serde::__private::Some(
723 match __A::next_value::<bool>(&mut __map) {
724 _serde::__private::Ok(__val) => __val,
725 _serde::__private::Err(__err) => {
726 return _serde::__private::Err(__err);
727 }
728 },
729 );
730 }
731 17usize => {
732 if _serde::__private::Option::is_some(
733 &m_bAllCharactersInScene,
734 ) {
735 return _serde::__private::Err(
736 <__A::Error as _serde::de::Error>::duplicate_field(
737 "bAllCharactersInScene",
738 ),
739 );
740 }
741 m_bAllCharactersInScene = _serde::__private::Some(
742 match __A::next_value::<bool>(&mut __map) {
743 _serde::__private::Ok(__val) => __val,
744 _serde::__private::Err(__err) => {
745 return _serde::__private::Err(__err);
746 }
747 },
748 );
749 }
750 18usize => {
751 if _serde::__private::Option::is_some(
752 &m_bAllCharactersAtMarks,
753 ) {
754 return _serde::__private::Err(
755 <__A::Error as _serde::de::Error>::duplicate_field(
756 "bAllCharactersAtMarks",
757 ),
758 );
759 }
760 m_bAllCharactersAtMarks = _serde::__private::Some(
761 match __A::next_value::<bool>(&mut __map) {
762 _serde::__private::Ok(__val) => __val,
763 _serde::__private::Err(__err) => {
764 return _serde::__private::Err(__err);
765 }
766 },
767 );
768 }
769 _ => {}
770 }
771 }
772 __A::pad(&mut __map, 15usize, 3usize)?;
773 let m_pClipGenerator = match m_pClipGenerator {
774 _serde::__private::Some(__field) => __field,
775 _serde::__private::None => {
776 return _serde::__private::Err(
777 <__A::Error as _serde::de::Error>::missing_field(
778 "pClipGenerator",
779 ),
780 );
781 }
782 };
783 let m_SyncAnimPrefix = match m_SyncAnimPrefix {
784 _serde::__private::Some(__field) => __field,
785 _serde::__private::None => {
786 return _serde::__private::Err(
787 <__A::Error as _serde::de::Error>::missing_field(
788 "SyncAnimPrefix",
789 ),
790 );
791 }
792 };
793 let m_bSyncClipIgnoreMarkPlacement = match m_bSyncClipIgnoreMarkPlacement {
794 _serde::__private::Some(__field) => __field,
795 _serde::__private::None => {
796 return _serde::__private::Err(
797 <__A::Error as _serde::de::Error>::missing_field(
798 "bSyncClipIgnoreMarkPlacement",
799 ),
800 );
801 }
802 };
803 let m_fGetToMarkTime = match m_fGetToMarkTime {
804 _serde::__private::Some(__field) => __field,
805 _serde::__private::None => {
806 return _serde::__private::Err(
807 <__A::Error as _serde::de::Error>::missing_field(
808 "fGetToMarkTime",
809 ),
810 );
811 }
812 };
813 let m_fMarkErrorThreshold = match m_fMarkErrorThreshold {
814 _serde::__private::Some(__field) => __field,
815 _serde::__private::None => {
816 return _serde::__private::Err(
817 <__A::Error as _serde::de::Error>::missing_field(
818 "fMarkErrorThreshold",
819 ),
820 );
821 }
822 };
823 let m_bLeadCharacter = match m_bLeadCharacter {
824 _serde::__private::Some(__field) => __field,
825 _serde::__private::None => {
826 return _serde::__private::Err(
827 <__A::Error as _serde::de::Error>::missing_field(
828 "bLeadCharacter",
829 ),
830 );
831 }
832 };
833 let m_bReorientSupportChar = match m_bReorientSupportChar {
834 _serde::__private::Some(__field) => __field,
835 _serde::__private::None => {
836 return _serde::__private::Err(
837 <__A::Error as _serde::de::Error>::missing_field(
838 "bReorientSupportChar",
839 ),
840 );
841 }
842 };
843 let m_bApplyMotionFromRoot = match m_bApplyMotionFromRoot {
844 _serde::__private::Some(__field) => __field,
845 _serde::__private::None => {
846 return _serde::__private::Err(
847 <__A::Error as _serde::de::Error>::missing_field(
848 "bApplyMotionFromRoot",
849 ),
850 );
851 }
852 };
853 let m_pSyncScene = match m_pSyncScene {
854 _serde::__private::Some(__field) => __field,
855 _serde::__private::None => {
856 return _serde::__private::Err(
857 <__A::Error as _serde::de::Error>::missing_field(
858 "pSyncScene",
859 ),
860 );
861 }
862 };
863 let m_StartMarkWS = match m_StartMarkWS {
864 _serde::__private::Some(__field) => __field,
865 _serde::__private::None => {
866 return _serde::__private::Err(
867 <__A::Error as _serde::de::Error>::missing_field(
868 "StartMarkWS",
869 ),
870 );
871 }
872 };
873 let m_EndMarkWS = match m_EndMarkWS {
874 _serde::__private::Some(__field) => __field,
875 _serde::__private::None => {
876 return _serde::__private::Err(
877 <__A::Error as _serde::de::Error>::missing_field(
878 "EndMarkWS",
879 ),
880 );
881 }
882 };
883 let m_StartMarkMS = match m_StartMarkMS {
884 _serde::__private::Some(__field) => __field,
885 _serde::__private::None => {
886 return _serde::__private::Err(
887 <__A::Error as _serde::de::Error>::missing_field(
888 "StartMarkMS",
889 ),
890 );
891 }
892 };
893 let m_fCurrentLerp = match m_fCurrentLerp {
894 _serde::__private::Some(__field) => __field,
895 _serde::__private::None => {
896 return _serde::__private::Err(
897 <__A::Error as _serde::de::Error>::missing_field(
898 "fCurrentLerp",
899 ),
900 );
901 }
902 };
903 let m_pLocalSyncBinding = match m_pLocalSyncBinding {
904 _serde::__private::Some(__field) => __field,
905 _serde::__private::None => {
906 return _serde::__private::Err(
907 <__A::Error as _serde::de::Error>::missing_field(
908 "pLocalSyncBinding",
909 ),
910 );
911 }
912 };
913 let m_pEventMap = match m_pEventMap {
914 _serde::__private::Some(__field) => __field,
915 _serde::__private::None => {
916 return _serde::__private::Err(
917 <__A::Error as _serde::de::Error>::missing_field(
918 "pEventMap",
919 ),
920 );
921 }
922 };
923 let m_sAnimationBindingIndex = match m_sAnimationBindingIndex {
924 _serde::__private::Some(__field) => __field,
925 _serde::__private::None => {
926 return _serde::__private::Err(
927 <__A::Error as _serde::de::Error>::missing_field(
928 "sAnimationBindingIndex",
929 ),
930 );
931 }
932 };
933 let m_bAtMark = match m_bAtMark {
934 _serde::__private::Some(__field) => __field,
935 _serde::__private::None => {
936 return _serde::__private::Err(
937 <__A::Error as _serde::de::Error>::missing_field("bAtMark"),
938 );
939 }
940 };
941 let m_bAllCharactersInScene = match m_bAllCharactersInScene {
942 _serde::__private::Some(__field) => __field,
943 _serde::__private::None => {
944 return _serde::__private::Err(
945 <__A::Error as _serde::de::Error>::missing_field(
946 "bAllCharactersInScene",
947 ),
948 );
949 }
950 };
951 let m_bAllCharactersAtMarks = match m_bAllCharactersAtMarks {
952 _serde::__private::Some(__field) => __field,
953 _serde::__private::None => {
954 return _serde::__private::Err(
955 <__A::Error as _serde::de::Error>::missing_field(
956 "bAllCharactersAtMarks",
957 ),
958 );
959 }
960 };
961 _serde::__private::Ok(BSSynchronizedClipGenerator {
962 __ptr,
963 parent,
964 m_pClipGenerator,
965 m_SyncAnimPrefix,
966 m_bSyncClipIgnoreMarkPlacement,
967 m_fGetToMarkTime,
968 m_fMarkErrorThreshold,
969 m_bLeadCharacter,
970 m_bReorientSupportChar,
971 m_bApplyMotionFromRoot,
972 m_pSyncScene,
973 m_StartMarkWS,
974 m_EndMarkWS,
975 m_StartMarkMS,
976 m_fCurrentLerp,
977 m_pLocalSyncBinding,
978 m_pEventMap,
979 m_sAnimationBindingIndex,
980 m_bAtMark,
981 m_bAllCharactersInScene,
982 m_bAllCharactersAtMarks,
983 })
984 }
985 #[allow(clippy::manual_unwrap_or_default)]
986 fn visit_struct<__A>(
987 self,
988 mut __map: __A,
989 ) -> _serde::__private::Result<Self::Value, __A::Error>
990 where
991 __A: _serde::de::MapAccess<'de>,
992 {
993 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
994 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
995 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
996 let mut m_pClipGenerator: _serde::__private::Option<Pointer> = _serde::__private::None;
997 let mut m_SyncAnimPrefix: _serde::__private::Option<CString<'de>> = _serde::__private::None;
998 let mut m_bSyncClipIgnoreMarkPlacement: _serde::__private::Option<
999 bool,
1000 > = _serde::__private::None;
1001 let mut m_fGetToMarkTime: _serde::__private::Option<f32> = _serde::__private::None;
1002 let mut m_fMarkErrorThreshold: _serde::__private::Option<f32> = _serde::__private::None;
1003 let mut m_bLeadCharacter: _serde::__private::Option<bool> = _serde::__private::None;
1004 let mut m_bReorientSupportChar: _serde::__private::Option<bool> = _serde::__private::None;
1005 let mut m_bApplyMotionFromRoot: _serde::__private::Option<bool> = _serde::__private::None;
1006 let mut m_sAnimationBindingIndex: _serde::__private::Option<i16> = _serde::__private::None;
1007 while let _serde::__private::Some(__key) = {
1008 __A::next_key::<__Field>(&mut __map)?
1009 } {
1010 match __key {
1011 __Field::m_variableBindingSet => {
1012 #[cfg(
1013 any(feature = "strict", feature = "ignore_duplicates")
1014 )]
1015 if _serde::__private::Option::is_some(
1016 &m_variableBindingSet,
1017 ) {
1018 #[cfg(feature = "ignore_duplicates")]
1019 {
1020 __A::skip_value(&mut __map)?;
1021 continue;
1022 }
1023 #[cfg(feature = "strict")]
1024 return _serde::__private::Err(
1025 <__A::Error as _serde::de::Error>::duplicate_field(
1026 "variableBindingSet",
1027 ),
1028 );
1029 }
1030 m_variableBindingSet = _serde::__private::Some(
1031 match __A::next_value::<Pointer>(&mut __map) {
1032 _serde::__private::Ok(__val) => __val,
1033 _serde::__private::Err(__err) => {
1034 return _serde::__private::Err(__err);
1035 }
1036 },
1037 );
1038 }
1039 __Field::m_userData => {
1040 #[cfg(
1041 any(feature = "strict", feature = "ignore_duplicates")
1042 )]
1043 if _serde::__private::Option::is_some(&m_userData) {
1044 #[cfg(feature = "ignore_duplicates")]
1045 {
1046 __A::skip_value(&mut __map)?;
1047 continue;
1048 }
1049 #[cfg(feature = "strict")]
1050 return _serde::__private::Err(
1051 <__A::Error as _serde::de::Error>::duplicate_field(
1052 "userData",
1053 ),
1054 );
1055 }
1056 m_userData = _serde::__private::Some(
1057 match __A::next_value::<Ulong>(&mut __map) {
1058 _serde::__private::Ok(__val) => __val,
1059 _serde::__private::Err(__err) => {
1060 return _serde::__private::Err(__err);
1061 }
1062 },
1063 );
1064 }
1065 __Field::m_name => {
1066 #[cfg(
1067 any(feature = "strict", feature = "ignore_duplicates")
1068 )]
1069 if _serde::__private::Option::is_some(&m_name) {
1070 #[cfg(feature = "ignore_duplicates")]
1071 {
1072 __A::skip_value(&mut __map)?;
1073 continue;
1074 }
1075 #[cfg(feature = "strict")]
1076 return _serde::__private::Err(
1077 <__A::Error as _serde::de::Error>::duplicate_field("name"),
1078 );
1079 }
1080 m_name = _serde::__private::Some(
1081 match __A::next_value::<StringPtr<'de>>(&mut __map) {
1082 _serde::__private::Ok(__val) => __val,
1083 _serde::__private::Err(__err) => {
1084 return _serde::__private::Err(__err);
1085 }
1086 },
1087 );
1088 }
1089 __Field::m_pClipGenerator => {
1090 #[cfg(
1091 any(feature = "strict", feature = "ignore_duplicates")
1092 )]
1093 if _serde::__private::Option::is_some(&m_pClipGenerator) {
1094 #[cfg(feature = "ignore_duplicates")]
1095 {
1096 __A::skip_value(&mut __map)?;
1097 continue;
1098 }
1099 #[cfg(feature = "strict")]
1100 return _serde::__private::Err(
1101 <__A::Error as _serde::de::Error>::duplicate_field(
1102 "pClipGenerator",
1103 ),
1104 );
1105 }
1106 m_pClipGenerator = _serde::__private::Some(
1107 match __A::next_value::<Pointer>(&mut __map) {
1108 _serde::__private::Ok(__val) => __val,
1109 _serde::__private::Err(__err) => {
1110 return _serde::__private::Err(__err);
1111 }
1112 },
1113 );
1114 }
1115 __Field::m_SyncAnimPrefix => {
1116 #[cfg(
1117 any(feature = "strict", feature = "ignore_duplicates")
1118 )]
1119 if _serde::__private::Option::is_some(&m_SyncAnimPrefix) {
1120 #[cfg(feature = "ignore_duplicates")]
1121 {
1122 __A::skip_value(&mut __map)?;
1123 continue;
1124 }
1125 #[cfg(feature = "strict")]
1126 return _serde::__private::Err(
1127 <__A::Error as _serde::de::Error>::duplicate_field(
1128 "SyncAnimPrefix",
1129 ),
1130 );
1131 }
1132 m_SyncAnimPrefix = _serde::__private::Some(
1133 match __A::next_value::<CString<'de>>(&mut __map) {
1134 _serde::__private::Ok(__val) => __val,
1135 _serde::__private::Err(__err) => {
1136 return _serde::__private::Err(__err);
1137 }
1138 },
1139 );
1140 }
1141 __Field::m_bSyncClipIgnoreMarkPlacement => {
1142 #[cfg(
1143 any(feature = "strict", feature = "ignore_duplicates")
1144 )]
1145 if _serde::__private::Option::is_some(
1146 &m_bSyncClipIgnoreMarkPlacement,
1147 ) {
1148 #[cfg(feature = "ignore_duplicates")]
1149 {
1150 __A::skip_value(&mut __map)?;
1151 continue;
1152 }
1153 #[cfg(feature = "strict")]
1154 return _serde::__private::Err(
1155 <__A::Error as _serde::de::Error>::duplicate_field(
1156 "bSyncClipIgnoreMarkPlacement",
1157 ),
1158 );
1159 }
1160 m_bSyncClipIgnoreMarkPlacement = _serde::__private::Some(
1161 match __A::next_value::<bool>(&mut __map) {
1162 _serde::__private::Ok(__val) => __val,
1163 _serde::__private::Err(__err) => {
1164 return _serde::__private::Err(__err);
1165 }
1166 },
1167 );
1168 }
1169 __Field::m_fGetToMarkTime => {
1170 #[cfg(
1171 any(feature = "strict", feature = "ignore_duplicates")
1172 )]
1173 if _serde::__private::Option::is_some(&m_fGetToMarkTime) {
1174 #[cfg(feature = "ignore_duplicates")]
1175 {
1176 __A::skip_value(&mut __map)?;
1177 continue;
1178 }
1179 #[cfg(feature = "strict")]
1180 return _serde::__private::Err(
1181 <__A::Error as _serde::de::Error>::duplicate_field(
1182 "fGetToMarkTime",
1183 ),
1184 );
1185 }
1186 m_fGetToMarkTime = _serde::__private::Some(
1187 match __A::next_value::<f32>(&mut __map) {
1188 _serde::__private::Ok(__val) => __val,
1189 _serde::__private::Err(__err) => {
1190 return _serde::__private::Err(__err);
1191 }
1192 },
1193 );
1194 }
1195 __Field::m_fMarkErrorThreshold => {
1196 #[cfg(
1197 any(feature = "strict", feature = "ignore_duplicates")
1198 )]
1199 if _serde::__private::Option::is_some(
1200 &m_fMarkErrorThreshold,
1201 ) {
1202 #[cfg(feature = "ignore_duplicates")]
1203 {
1204 __A::skip_value(&mut __map)?;
1205 continue;
1206 }
1207 #[cfg(feature = "strict")]
1208 return _serde::__private::Err(
1209 <__A::Error as _serde::de::Error>::duplicate_field(
1210 "fMarkErrorThreshold",
1211 ),
1212 );
1213 }
1214 m_fMarkErrorThreshold = _serde::__private::Some(
1215 match __A::next_value::<f32>(&mut __map) {
1216 _serde::__private::Ok(__val) => __val,
1217 _serde::__private::Err(__err) => {
1218 return _serde::__private::Err(__err);
1219 }
1220 },
1221 );
1222 }
1223 __Field::m_bLeadCharacter => {
1224 #[cfg(
1225 any(feature = "strict", feature = "ignore_duplicates")
1226 )]
1227 if _serde::__private::Option::is_some(&m_bLeadCharacter) {
1228 #[cfg(feature = "ignore_duplicates")]
1229 {
1230 __A::skip_value(&mut __map)?;
1231 continue;
1232 }
1233 #[cfg(feature = "strict")]
1234 return _serde::__private::Err(
1235 <__A::Error as _serde::de::Error>::duplicate_field(
1236 "bLeadCharacter",
1237 ),
1238 );
1239 }
1240 m_bLeadCharacter = _serde::__private::Some(
1241 match __A::next_value::<bool>(&mut __map) {
1242 _serde::__private::Ok(__val) => __val,
1243 _serde::__private::Err(__err) => {
1244 return _serde::__private::Err(__err);
1245 }
1246 },
1247 );
1248 }
1249 __Field::m_bReorientSupportChar => {
1250 #[cfg(
1251 any(feature = "strict", feature = "ignore_duplicates")
1252 )]
1253 if _serde::__private::Option::is_some(
1254 &m_bReorientSupportChar,
1255 ) {
1256 #[cfg(feature = "ignore_duplicates")]
1257 {
1258 __A::skip_value(&mut __map)?;
1259 continue;
1260 }
1261 #[cfg(feature = "strict")]
1262 return _serde::__private::Err(
1263 <__A::Error as _serde::de::Error>::duplicate_field(
1264 "bReorientSupportChar",
1265 ),
1266 );
1267 }
1268 m_bReorientSupportChar = _serde::__private::Some(
1269 match __A::next_value::<bool>(&mut __map) {
1270 _serde::__private::Ok(__val) => __val,
1271 _serde::__private::Err(__err) => {
1272 return _serde::__private::Err(__err);
1273 }
1274 },
1275 );
1276 }
1277 __Field::m_bApplyMotionFromRoot => {
1278 #[cfg(
1279 any(feature = "strict", feature = "ignore_duplicates")
1280 )]
1281 if _serde::__private::Option::is_some(
1282 &m_bApplyMotionFromRoot,
1283 ) {
1284 #[cfg(feature = "ignore_duplicates")]
1285 {
1286 __A::skip_value(&mut __map)?;
1287 continue;
1288 }
1289 #[cfg(feature = "strict")]
1290 return _serde::__private::Err(
1291 <__A::Error as _serde::de::Error>::duplicate_field(
1292 "bApplyMotionFromRoot",
1293 ),
1294 );
1295 }
1296 m_bApplyMotionFromRoot = _serde::__private::Some(
1297 match __A::next_value::<bool>(&mut __map) {
1298 _serde::__private::Ok(__val) => __val,
1299 _serde::__private::Err(__err) => {
1300 return _serde::__private::Err(__err);
1301 }
1302 },
1303 );
1304 }
1305 __Field::m_sAnimationBindingIndex => {
1306 #[cfg(
1307 any(feature = "strict", feature = "ignore_duplicates")
1308 )]
1309 if _serde::__private::Option::is_some(
1310 &m_sAnimationBindingIndex,
1311 ) {
1312 #[cfg(feature = "ignore_duplicates")]
1313 {
1314 __A::skip_value(&mut __map)?;
1315 continue;
1316 }
1317 #[cfg(feature = "strict")]
1318 return _serde::__private::Err(
1319 <__A::Error as _serde::de::Error>::duplicate_field(
1320 "sAnimationBindingIndex",
1321 ),
1322 );
1323 }
1324 m_sAnimationBindingIndex = _serde::__private::Some(
1325 match __A::next_value::<i16>(&mut __map) {
1326 _serde::__private::Ok(__val) => __val,
1327 _serde::__private::Err(__err) => {
1328 return _serde::__private::Err(__err);
1329 }
1330 },
1331 );
1332 }
1333 _ => __A::skip_value(&mut __map)?,
1334 }
1335 }
1336 let m_variableBindingSet = match m_variableBindingSet {
1337 _serde::__private::Some(__field) => __field,
1338 _serde::__private::None => {
1339 #[cfg(feature = "strict")]
1340 return _serde::__private::Err(
1341 <__A::Error as _serde::de::Error>::missing_field(
1342 "variableBindingSet",
1343 ),
1344 );
1345 #[cfg(not(feature = "strict"))] Default::default()
1346 }
1347 };
1348 let m_userData = match m_userData {
1349 _serde::__private::Some(__field) => __field,
1350 _serde::__private::None => {
1351 #[cfg(feature = "strict")]
1352 return _serde::__private::Err(
1353 <__A::Error as _serde::de::Error>::missing_field("userData"),
1354 );
1355 #[cfg(not(feature = "strict"))] Default::default()
1356 }
1357 };
1358 let m_name = match m_name {
1359 _serde::__private::Some(__field) => __field,
1360 _serde::__private::None => {
1361 #[cfg(feature = "strict")]
1362 return _serde::__private::Err(
1363 <__A::Error as _serde::de::Error>::missing_field("name"),
1364 );
1365 #[cfg(not(feature = "strict"))] Default::default()
1366 }
1367 };
1368 let m_pClipGenerator = match m_pClipGenerator {
1369 _serde::__private::Some(__field) => __field,
1370 _serde::__private::None => {
1371 #[cfg(feature = "strict")]
1372 return _serde::__private::Err(
1373 <__A::Error as _serde::de::Error>::missing_field(
1374 "pClipGenerator",
1375 ),
1376 );
1377 #[cfg(not(feature = "strict"))] Default::default()
1378 }
1379 };
1380 let m_SyncAnimPrefix = match m_SyncAnimPrefix {
1381 _serde::__private::Some(__field) => __field,
1382 _serde::__private::None => {
1383 #[cfg(feature = "strict")]
1384 return _serde::__private::Err(
1385 <__A::Error as _serde::de::Error>::missing_field(
1386 "SyncAnimPrefix",
1387 ),
1388 );
1389 #[cfg(not(feature = "strict"))] Default::default()
1390 }
1391 };
1392 let m_bSyncClipIgnoreMarkPlacement = match m_bSyncClipIgnoreMarkPlacement {
1393 _serde::__private::Some(__field) => __field,
1394 _serde::__private::None => {
1395 #[cfg(feature = "strict")]
1396 return _serde::__private::Err(
1397 <__A::Error as _serde::de::Error>::missing_field(
1398 "bSyncClipIgnoreMarkPlacement",
1399 ),
1400 );
1401 #[cfg(not(feature = "strict"))] Default::default()
1402 }
1403 };
1404 let m_fGetToMarkTime = match m_fGetToMarkTime {
1405 _serde::__private::Some(__field) => __field,
1406 _serde::__private::None => {
1407 #[cfg(feature = "strict")]
1408 return _serde::__private::Err(
1409 <__A::Error as _serde::de::Error>::missing_field(
1410 "fGetToMarkTime",
1411 ),
1412 );
1413 #[cfg(not(feature = "strict"))] Default::default()
1414 }
1415 };
1416 let m_fMarkErrorThreshold = match m_fMarkErrorThreshold {
1417 _serde::__private::Some(__field) => __field,
1418 _serde::__private::None => {
1419 #[cfg(feature = "strict")]
1420 return _serde::__private::Err(
1421 <__A::Error as _serde::de::Error>::missing_field(
1422 "fMarkErrorThreshold",
1423 ),
1424 );
1425 #[cfg(not(feature = "strict"))] Default::default()
1426 }
1427 };
1428 let m_bLeadCharacter = match m_bLeadCharacter {
1429 _serde::__private::Some(__field) => __field,
1430 _serde::__private::None => {
1431 #[cfg(feature = "strict")]
1432 return _serde::__private::Err(
1433 <__A::Error as _serde::de::Error>::missing_field(
1434 "bLeadCharacter",
1435 ),
1436 );
1437 #[cfg(not(feature = "strict"))] Default::default()
1438 }
1439 };
1440 let m_bReorientSupportChar = match m_bReorientSupportChar {
1441 _serde::__private::Some(__field) => __field,
1442 _serde::__private::None => {
1443 #[cfg(feature = "strict")]
1444 return _serde::__private::Err(
1445 <__A::Error as _serde::de::Error>::missing_field(
1446 "bReorientSupportChar",
1447 ),
1448 );
1449 #[cfg(not(feature = "strict"))] Default::default()
1450 }
1451 };
1452 let m_bApplyMotionFromRoot = match m_bApplyMotionFromRoot {
1453 _serde::__private::Some(__field) => __field,
1454 _serde::__private::None => {
1455 #[cfg(feature = "strict")]
1456 return _serde::__private::Err(
1457 <__A::Error as _serde::de::Error>::missing_field(
1458 "bApplyMotionFromRoot",
1459 ),
1460 );
1461 #[cfg(not(feature = "strict"))] Default::default()
1462 }
1463 };
1464 let m_sAnimationBindingIndex = match m_sAnimationBindingIndex {
1465 _serde::__private::Some(__field) => __field,
1466 _serde::__private::None => {
1467 #[cfg(feature = "strict")]
1468 return _serde::__private::Err(
1469 <__A::Error as _serde::de::Error>::missing_field(
1470 "sAnimationBindingIndex",
1471 ),
1472 );
1473 #[cfg(not(feature = "strict"))] Default::default()
1474 }
1475 };
1476 let __ptr = None;
1477 let parent = hkBaseObject { __ptr };
1478 let parent = hkReferencedObject {
1479 __ptr,
1480 parent,
1481 ..Default::default()
1482 };
1483 let parent = hkbBindable {
1484 __ptr,
1485 parent,
1486 m_variableBindingSet,
1487 ..Default::default()
1488 };
1489 let parent = hkbNode {
1490 __ptr,
1491 parent,
1492 m_userData,
1493 m_name,
1494 ..Default::default()
1495 };
1496 let parent = hkbGenerator { __ptr, parent };
1497 let __ptr = __A::class_ptr(&mut __map);
1498 _serde::__private::Ok(BSSynchronizedClipGenerator {
1499 __ptr,
1500 parent,
1501 m_pClipGenerator,
1502 m_SyncAnimPrefix,
1503 m_bSyncClipIgnoreMarkPlacement,
1504 m_fGetToMarkTime,
1505 m_fMarkErrorThreshold,
1506 m_bLeadCharacter,
1507 m_bReorientSupportChar,
1508 m_bApplyMotionFromRoot,
1509 m_sAnimationBindingIndex,
1510 ..Default::default()
1511 })
1512 }
1513 }
1514 const FIELDS: &[&str] = &[
1515 "pClipGenerator",
1516 "SyncAnimPrefix",
1517 "bSyncClipIgnoreMarkPlacement",
1518 "fGetToMarkTime",
1519 "fMarkErrorThreshold",
1520 "bLeadCharacter",
1521 "bReorientSupportChar",
1522 "bApplyMotionFromRoot",
1523 "pSyncScene",
1524 "StartMarkWS",
1525 "EndMarkWS",
1526 "StartMarkMS",
1527 "fCurrentLerp",
1528 "pLocalSyncBinding",
1529 "pEventMap",
1530 "sAnimationBindingIndex",
1531 "bAtMark",
1532 "bAllCharactersInScene",
1533 "bAllCharactersAtMarks",
1534 ];
1535 _serde::Deserializer::deserialize_struct(
1536 deserializer,
1537 "BSSynchronizedClipGenerator",
1538 FIELDS,
1539 __BSSynchronizedClipGeneratorVisitor {
1540 marker: _serde::__private::PhantomData::<
1541 BSSynchronizedClipGenerator,
1542 >,
1543 lifetime: _serde::__private::PhantomData,
1544 },
1545 )
1546 }
1547 }
1548};