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