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