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 BSIsActiveModifier<'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: hkbModifier<'a>,
31 #[cfg_attr(feature = "json_schema", schemars(rename = "bIsActive0"))]
36 #[cfg_attr(feature = "serde", serde(rename = "bIsActive0"))]
37 pub m_bIsActive0: bool,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "bInvertActive0"))]
43 #[cfg_attr(feature = "serde", serde(rename = "bInvertActive0"))]
44 pub m_bInvertActive0: bool,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "bIsActive1"))]
50 #[cfg_attr(feature = "serde", serde(rename = "bIsActive1"))]
51 pub m_bIsActive1: bool,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "bInvertActive1"))]
57 #[cfg_attr(feature = "serde", serde(rename = "bInvertActive1"))]
58 pub m_bInvertActive1: bool,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "bIsActive2"))]
64 #[cfg_attr(feature = "serde", serde(rename = "bIsActive2"))]
65 pub m_bIsActive2: bool,
66 #[cfg_attr(feature = "json_schema", schemars(rename = "bInvertActive2"))]
71 #[cfg_attr(feature = "serde", serde(rename = "bInvertActive2"))]
72 pub m_bInvertActive2: bool,
73 #[cfg_attr(feature = "json_schema", schemars(rename = "bIsActive3"))]
78 #[cfg_attr(feature = "serde", serde(rename = "bIsActive3"))]
79 pub m_bIsActive3: bool,
80 #[cfg_attr(feature = "json_schema", schemars(rename = "bInvertActive3"))]
85 #[cfg_attr(feature = "serde", serde(rename = "bInvertActive3"))]
86 pub m_bInvertActive3: bool,
87 #[cfg_attr(feature = "json_schema", schemars(rename = "bIsActive4"))]
92 #[cfg_attr(feature = "serde", serde(rename = "bIsActive4"))]
93 pub m_bIsActive4: bool,
94 #[cfg_attr(feature = "json_schema", schemars(rename = "bInvertActive4"))]
99 #[cfg_attr(feature = "serde", serde(rename = "bInvertActive4"))]
100 pub m_bInvertActive4: bool,
101}
102const _: () = {
103 use havok_serde as _serde;
104 impl<'a> _serde::HavokClass for BSIsActiveModifier<'a> {
105 #[inline]
106 fn name(&self) -> &'static str {
107 "BSIsActiveModifier"
108 }
109 #[inline]
110 fn signature(&self) -> _serde::__private::Signature {
111 _serde::__private::Signature::new(0xb0fde45a)
112 }
113 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
114 fn deps_indexes(&self) -> Vec<usize> {
115 let mut v = Vec::new();
116 v.push(self.parent.parent.parent.m_variableBindingSet.get());
117 v
118 }
119 }
120 impl<'a> _serde::Serialize for BSIsActiveModifier<'a> {
121 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
122 where
123 S: _serde::ser::Serializer,
124 {
125 let class_meta = self
126 .__ptr
127 .map(|name| (name, _serde::__private::Signature::new(0xb0fde45a)));
128 let mut serializer = __serializer
129 .serialize_struct("BSIsActiveModifier", class_meta, (56u64, 96u64))?;
130 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
131 serializer
132 .skip_field(
133 "memSizeAndFlags",
134 &self.parent.parent.parent.parent.m_memSizeAndFlags,
135 )?;
136 serializer
137 .skip_field(
138 "referenceCount",
139 &self.parent.parent.parent.parent.m_referenceCount,
140 )?;
141 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
142 serializer
143 .serialize_field(
144 "variableBindingSet",
145 &self.parent.parent.parent.m_variableBindingSet,
146 )?;
147 serializer
148 .skip_array_field(
149 "cachedBindables",
150 &self.parent.parent.parent.m_cachedBindables,
151 TypeSize::NonPtr,
152 )?;
153 serializer
154 .skip_field(
155 "areBindablesCached",
156 &self.parent.parent.parent.m_areBindablesCached,
157 )?;
158 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
159 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
160 serializer.serialize_field("name", &self.parent.parent.m_name)?;
161 serializer.skip_field("id", &self.parent.parent.m_id)?;
162 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
163 serializer
164 .skip_fixed_array_field(
165 "padNode",
166 self.parent.parent.m_padNode.as_slice(),
167 TypeSize::NonPtr,
168 )?;
169 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
170 serializer.serialize_field("enable", &self.parent.m_enable)?;
171 serializer
172 .skip_fixed_array_field(
173 "padModifier",
174 self.parent.m_padModifier.as_slice(),
175 TypeSize::NonPtr,
176 )?;
177 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
178 serializer.serialize_field("bIsActive0", &self.m_bIsActive0)?;
179 serializer.serialize_field("bInvertActive0", &self.m_bInvertActive0)?;
180 serializer.serialize_field("bIsActive1", &self.m_bIsActive1)?;
181 serializer.serialize_field("bInvertActive1", &self.m_bInvertActive1)?;
182 serializer.serialize_field("bIsActive2", &self.m_bIsActive2)?;
183 serializer.serialize_field("bInvertActive2", &self.m_bInvertActive2)?;
184 serializer.serialize_field("bIsActive3", &self.m_bIsActive3)?;
185 serializer.serialize_field("bInvertActive3", &self.m_bInvertActive3)?;
186 serializer.serialize_field("bIsActive4", &self.m_bIsActive4)?;
187 serializer.serialize_field("bInvertActive4", &self.m_bInvertActive4)?;
188 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 6usize].as_slice())?;
189 serializer.end()
190 }
191 }
192};
193#[doc(hidden)]
194#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
195const _: () = {
196 use havok_serde as _serde;
197 #[automatically_derived]
198 impl<'de> _serde::Deserialize<'de> for BSIsActiveModifier<'de> {
199 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
200 where
201 __D: _serde::Deserializer<'de>,
202 {
203 #[allow(non_camel_case_types)]
204 enum __Field {
205 m_variableBindingSet,
206 m_userData,
207 m_name,
208 m_enable,
209 m_bIsActive0,
210 m_bInvertActive0,
211 m_bIsActive1,
212 m_bInvertActive1,
213 m_bIsActive2,
214 m_bInvertActive2,
215 m_bIsActive3,
216 m_bInvertActive3,
217 m_bIsActive4,
218 m_bInvertActive4,
219 __ignore,
220 }
221 struct __FieldVisitor;
222 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
223 type Value = __Field;
224 fn expecting(
225 &self,
226 __formatter: &mut core::fmt::Formatter,
227 ) -> core::fmt::Result {
228 core::fmt::Formatter::write_str(__formatter, "field identifier")
229 }
230 #[allow(clippy::match_single_binding)]
232 #[allow(clippy::reversed_empty_ranges)]
233 #[allow(clippy::single_match)]
234 fn visit_key<__E>(
235 self,
236 __value: &str,
237 ) -> core::result::Result<Self::Value, __E>
238 where
239 __E: _serde::de::Error,
240 {
241 match __value {
242 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
243 "userData" => Ok(__Field::m_userData),
244 "name" => Ok(__Field::m_name),
245 "enable" => Ok(__Field::m_enable),
246 "bIsActive0" => Ok(__Field::m_bIsActive0),
247 "bInvertActive0" => Ok(__Field::m_bInvertActive0),
248 "bIsActive1" => Ok(__Field::m_bIsActive1),
249 "bInvertActive1" => Ok(__Field::m_bInvertActive1),
250 "bIsActive2" => Ok(__Field::m_bIsActive2),
251 "bInvertActive2" => Ok(__Field::m_bInvertActive2),
252 "bIsActive3" => Ok(__Field::m_bIsActive3),
253 "bInvertActive3" => Ok(__Field::m_bInvertActive3),
254 "bIsActive4" => Ok(__Field::m_bIsActive4),
255 "bInvertActive4" => Ok(__Field::m_bInvertActive4),
256 _ => Ok(__Field::__ignore),
257 }
258 }
259 }
260 impl<'de> _serde::Deserialize<'de> for __Field {
261 #[inline]
262 fn deserialize<__D>(
263 __deserializer: __D,
264 ) -> core::result::Result<Self, __D::Error>
265 where
266 __D: _serde::Deserializer<'de>,
267 {
268 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
269 }
270 }
271 struct __BSIsActiveModifierVisitor<'de> {
272 marker: _serde::__private::PhantomData<BSIsActiveModifier<'de>>,
273 lifetime: _serde::__private::PhantomData<&'de ()>,
274 }
275 #[allow(clippy::match_single_binding)]
276 #[allow(clippy::reversed_empty_ranges)]
277 #[allow(clippy::single_match)]
278 impl<'de> _serde::de::Visitor<'de> for __BSIsActiveModifierVisitor<'de> {
279 type Value = BSIsActiveModifier<'de>;
280 fn expecting(
281 &self,
282 __formatter: &mut core::fmt::Formatter,
283 ) -> core::fmt::Result {
284 core::fmt::Formatter::write_str(
285 __formatter,
286 "struct BSIsActiveModifier",
287 )
288 }
289 fn visit_struct_for_bytes<__A>(
290 self,
291 mut __map: __A,
292 ) -> _serde::__private::Result<Self::Value, __A::Error>
293 where
294 __A: _serde::de::MapAccess<'de>,
295 {
296 let __ptr = __A::class_ptr(&mut __map);
297 let parent = __A::parent_value(&mut __map)?;
298 let mut m_bIsActive0: _serde::__private::Option<bool> = _serde::__private::None;
299 let mut m_bInvertActive0: _serde::__private::Option<bool> = _serde::__private::None;
300 let mut m_bIsActive1: _serde::__private::Option<bool> = _serde::__private::None;
301 let mut m_bInvertActive1: _serde::__private::Option<bool> = _serde::__private::None;
302 let mut m_bIsActive2: _serde::__private::Option<bool> = _serde::__private::None;
303 let mut m_bInvertActive2: _serde::__private::Option<bool> = _serde::__private::None;
304 let mut m_bIsActive3: _serde::__private::Option<bool> = _serde::__private::None;
305 let mut m_bInvertActive3: _serde::__private::Option<bool> = _serde::__private::None;
306 let mut m_bIsActive4: _serde::__private::Option<bool> = _serde::__private::None;
307 let mut m_bInvertActive4: _serde::__private::Option<bool> = _serde::__private::None;
308 for i in 0..10usize {
309 match i {
310 0usize => {
311 if _serde::__private::Option::is_some(&m_bIsActive0) {
312 return _serde::__private::Err(
313 <__A::Error as _serde::de::Error>::duplicate_field(
314 "bIsActive0",
315 ),
316 );
317 }
318 m_bIsActive0 = _serde::__private::Some(
319 match __A::next_value::<bool>(&mut __map) {
320 _serde::__private::Ok(__val) => __val,
321 _serde::__private::Err(__err) => {
322 return _serde::__private::Err(__err);
323 }
324 },
325 );
326 }
327 1usize => {
328 if _serde::__private::Option::is_some(&m_bInvertActive0) {
329 return _serde::__private::Err(
330 <__A::Error as _serde::de::Error>::duplicate_field(
331 "bInvertActive0",
332 ),
333 );
334 }
335 m_bInvertActive0 = _serde::__private::Some(
336 match __A::next_value::<bool>(&mut __map) {
337 _serde::__private::Ok(__val) => __val,
338 _serde::__private::Err(__err) => {
339 return _serde::__private::Err(__err);
340 }
341 },
342 );
343 }
344 2usize => {
345 if _serde::__private::Option::is_some(&m_bIsActive1) {
346 return _serde::__private::Err(
347 <__A::Error as _serde::de::Error>::duplicate_field(
348 "bIsActive1",
349 ),
350 );
351 }
352 m_bIsActive1 = _serde::__private::Some(
353 match __A::next_value::<bool>(&mut __map) {
354 _serde::__private::Ok(__val) => __val,
355 _serde::__private::Err(__err) => {
356 return _serde::__private::Err(__err);
357 }
358 },
359 );
360 }
361 3usize => {
362 if _serde::__private::Option::is_some(&m_bInvertActive1) {
363 return _serde::__private::Err(
364 <__A::Error as _serde::de::Error>::duplicate_field(
365 "bInvertActive1",
366 ),
367 );
368 }
369 m_bInvertActive1 = _serde::__private::Some(
370 match __A::next_value::<bool>(&mut __map) {
371 _serde::__private::Ok(__val) => __val,
372 _serde::__private::Err(__err) => {
373 return _serde::__private::Err(__err);
374 }
375 },
376 );
377 }
378 4usize => {
379 if _serde::__private::Option::is_some(&m_bIsActive2) {
380 return _serde::__private::Err(
381 <__A::Error as _serde::de::Error>::duplicate_field(
382 "bIsActive2",
383 ),
384 );
385 }
386 m_bIsActive2 = _serde::__private::Some(
387 match __A::next_value::<bool>(&mut __map) {
388 _serde::__private::Ok(__val) => __val,
389 _serde::__private::Err(__err) => {
390 return _serde::__private::Err(__err);
391 }
392 },
393 );
394 }
395 5usize => {
396 if _serde::__private::Option::is_some(&m_bInvertActive2) {
397 return _serde::__private::Err(
398 <__A::Error as _serde::de::Error>::duplicate_field(
399 "bInvertActive2",
400 ),
401 );
402 }
403 m_bInvertActive2 = _serde::__private::Some(
404 match __A::next_value::<bool>(&mut __map) {
405 _serde::__private::Ok(__val) => __val,
406 _serde::__private::Err(__err) => {
407 return _serde::__private::Err(__err);
408 }
409 },
410 );
411 }
412 6usize => {
413 if _serde::__private::Option::is_some(&m_bIsActive3) {
414 return _serde::__private::Err(
415 <__A::Error as _serde::de::Error>::duplicate_field(
416 "bIsActive3",
417 ),
418 );
419 }
420 m_bIsActive3 = _serde::__private::Some(
421 match __A::next_value::<bool>(&mut __map) {
422 _serde::__private::Ok(__val) => __val,
423 _serde::__private::Err(__err) => {
424 return _serde::__private::Err(__err);
425 }
426 },
427 );
428 }
429 7usize => {
430 if _serde::__private::Option::is_some(&m_bInvertActive3) {
431 return _serde::__private::Err(
432 <__A::Error as _serde::de::Error>::duplicate_field(
433 "bInvertActive3",
434 ),
435 );
436 }
437 m_bInvertActive3 = _serde::__private::Some(
438 match __A::next_value::<bool>(&mut __map) {
439 _serde::__private::Ok(__val) => __val,
440 _serde::__private::Err(__err) => {
441 return _serde::__private::Err(__err);
442 }
443 },
444 );
445 }
446 8usize => {
447 if _serde::__private::Option::is_some(&m_bIsActive4) {
448 return _serde::__private::Err(
449 <__A::Error as _serde::de::Error>::duplicate_field(
450 "bIsActive4",
451 ),
452 );
453 }
454 m_bIsActive4 = _serde::__private::Some(
455 match __A::next_value::<bool>(&mut __map) {
456 _serde::__private::Ok(__val) => __val,
457 _serde::__private::Err(__err) => {
458 return _serde::__private::Err(__err);
459 }
460 },
461 );
462 }
463 9usize => {
464 if _serde::__private::Option::is_some(&m_bInvertActive4) {
465 return _serde::__private::Err(
466 <__A::Error as _serde::de::Error>::duplicate_field(
467 "bInvertActive4",
468 ),
469 );
470 }
471 m_bInvertActive4 = _serde::__private::Some(
472 match __A::next_value::<bool>(&mut __map) {
473 _serde::__private::Ok(__val) => __val,
474 _serde::__private::Err(__err) => {
475 return _serde::__private::Err(__err);
476 }
477 },
478 );
479 }
480 _ => {}
481 }
482 }
483 __A::pad(&mut __map, 2usize, 6usize)?;
484 let m_bIsActive0 = match m_bIsActive0 {
485 _serde::__private::Some(__field) => __field,
486 _serde::__private::None => {
487 return _serde::__private::Err(
488 <__A::Error as _serde::de::Error>::missing_field(
489 "bIsActive0",
490 ),
491 );
492 }
493 };
494 let m_bInvertActive0 = match m_bInvertActive0 {
495 _serde::__private::Some(__field) => __field,
496 _serde::__private::None => {
497 return _serde::__private::Err(
498 <__A::Error as _serde::de::Error>::missing_field(
499 "bInvertActive0",
500 ),
501 );
502 }
503 };
504 let m_bIsActive1 = match m_bIsActive1 {
505 _serde::__private::Some(__field) => __field,
506 _serde::__private::None => {
507 return _serde::__private::Err(
508 <__A::Error as _serde::de::Error>::missing_field(
509 "bIsActive1",
510 ),
511 );
512 }
513 };
514 let m_bInvertActive1 = match m_bInvertActive1 {
515 _serde::__private::Some(__field) => __field,
516 _serde::__private::None => {
517 return _serde::__private::Err(
518 <__A::Error as _serde::de::Error>::missing_field(
519 "bInvertActive1",
520 ),
521 );
522 }
523 };
524 let m_bIsActive2 = match m_bIsActive2 {
525 _serde::__private::Some(__field) => __field,
526 _serde::__private::None => {
527 return _serde::__private::Err(
528 <__A::Error as _serde::de::Error>::missing_field(
529 "bIsActive2",
530 ),
531 );
532 }
533 };
534 let m_bInvertActive2 = match m_bInvertActive2 {
535 _serde::__private::Some(__field) => __field,
536 _serde::__private::None => {
537 return _serde::__private::Err(
538 <__A::Error as _serde::de::Error>::missing_field(
539 "bInvertActive2",
540 ),
541 );
542 }
543 };
544 let m_bIsActive3 = match m_bIsActive3 {
545 _serde::__private::Some(__field) => __field,
546 _serde::__private::None => {
547 return _serde::__private::Err(
548 <__A::Error as _serde::de::Error>::missing_field(
549 "bIsActive3",
550 ),
551 );
552 }
553 };
554 let m_bInvertActive3 = match m_bInvertActive3 {
555 _serde::__private::Some(__field) => __field,
556 _serde::__private::None => {
557 return _serde::__private::Err(
558 <__A::Error as _serde::de::Error>::missing_field(
559 "bInvertActive3",
560 ),
561 );
562 }
563 };
564 let m_bIsActive4 = match m_bIsActive4 {
565 _serde::__private::Some(__field) => __field,
566 _serde::__private::None => {
567 return _serde::__private::Err(
568 <__A::Error as _serde::de::Error>::missing_field(
569 "bIsActive4",
570 ),
571 );
572 }
573 };
574 let m_bInvertActive4 = match m_bInvertActive4 {
575 _serde::__private::Some(__field) => __field,
576 _serde::__private::None => {
577 return _serde::__private::Err(
578 <__A::Error as _serde::de::Error>::missing_field(
579 "bInvertActive4",
580 ),
581 );
582 }
583 };
584 _serde::__private::Ok(BSIsActiveModifier {
585 __ptr,
586 parent,
587 m_bIsActive0,
588 m_bInvertActive0,
589 m_bIsActive1,
590 m_bInvertActive1,
591 m_bIsActive2,
592 m_bInvertActive2,
593 m_bIsActive3,
594 m_bInvertActive3,
595 m_bIsActive4,
596 m_bInvertActive4,
597 })
598 }
599 #[allow(clippy::manual_unwrap_or_default)]
600 fn visit_struct<__A>(
601 self,
602 mut __map: __A,
603 ) -> _serde::__private::Result<Self::Value, __A::Error>
604 where
605 __A: _serde::de::MapAccess<'de>,
606 {
607 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
608 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
609 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
610 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
611 let mut m_bIsActive0: _serde::__private::Option<bool> = _serde::__private::None;
612 let mut m_bInvertActive0: _serde::__private::Option<bool> = _serde::__private::None;
613 let mut m_bIsActive1: _serde::__private::Option<bool> = _serde::__private::None;
614 let mut m_bInvertActive1: _serde::__private::Option<bool> = _serde::__private::None;
615 let mut m_bIsActive2: _serde::__private::Option<bool> = _serde::__private::None;
616 let mut m_bInvertActive2: _serde::__private::Option<bool> = _serde::__private::None;
617 let mut m_bIsActive3: _serde::__private::Option<bool> = _serde::__private::None;
618 let mut m_bInvertActive3: _serde::__private::Option<bool> = _serde::__private::None;
619 let mut m_bIsActive4: _serde::__private::Option<bool> = _serde::__private::None;
620 let mut m_bInvertActive4: _serde::__private::Option<bool> = _serde::__private::None;
621 while let _serde::__private::Some(__key) = {
622 __A::next_key::<__Field>(&mut __map)?
623 } {
624 match __key {
625 __Field::m_variableBindingSet => {
626 #[cfg(
627 any(feature = "strict", feature = "ignore_duplicates")
628 )]
629 if _serde::__private::Option::is_some(
630 &m_variableBindingSet,
631 ) {
632 #[cfg(feature = "ignore_duplicates")]
633 {
634 __A::skip_value(&mut __map)?;
635 continue;
636 }
637 #[cfg(feature = "strict")]
638 return _serde::__private::Err(
639 <__A::Error as _serde::de::Error>::duplicate_field(
640 "variableBindingSet",
641 ),
642 );
643 }
644 m_variableBindingSet = _serde::__private::Some(
645 match __A::next_value::<Pointer>(&mut __map) {
646 _serde::__private::Ok(__val) => __val,
647 _serde::__private::Err(__err) => {
648 return _serde::__private::Err(__err);
649 }
650 },
651 );
652 }
653 __Field::m_userData => {
654 #[cfg(
655 any(feature = "strict", feature = "ignore_duplicates")
656 )]
657 if _serde::__private::Option::is_some(&m_userData) {
658 #[cfg(feature = "ignore_duplicates")]
659 {
660 __A::skip_value(&mut __map)?;
661 continue;
662 }
663 #[cfg(feature = "strict")]
664 return _serde::__private::Err(
665 <__A::Error as _serde::de::Error>::duplicate_field(
666 "userData",
667 ),
668 );
669 }
670 m_userData = _serde::__private::Some(
671 match __A::next_value::<Ulong>(&mut __map) {
672 _serde::__private::Ok(__val) => __val,
673 _serde::__private::Err(__err) => {
674 return _serde::__private::Err(__err);
675 }
676 },
677 );
678 }
679 __Field::m_name => {
680 #[cfg(
681 any(feature = "strict", feature = "ignore_duplicates")
682 )]
683 if _serde::__private::Option::is_some(&m_name) {
684 #[cfg(feature = "ignore_duplicates")]
685 {
686 __A::skip_value(&mut __map)?;
687 continue;
688 }
689 #[cfg(feature = "strict")]
690 return _serde::__private::Err(
691 <__A::Error as _serde::de::Error>::duplicate_field("name"),
692 );
693 }
694 m_name = _serde::__private::Some(
695 match __A::next_value::<StringPtr<'de>>(&mut __map) {
696 _serde::__private::Ok(__val) => __val,
697 _serde::__private::Err(__err) => {
698 return _serde::__private::Err(__err);
699 }
700 },
701 );
702 }
703 __Field::m_enable => {
704 #[cfg(
705 any(feature = "strict", feature = "ignore_duplicates")
706 )]
707 if _serde::__private::Option::is_some(&m_enable) {
708 #[cfg(feature = "ignore_duplicates")]
709 {
710 __A::skip_value(&mut __map)?;
711 continue;
712 }
713 #[cfg(feature = "strict")]
714 return _serde::__private::Err(
715 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
716 );
717 }
718 m_enable = _serde::__private::Some(
719 match __A::next_value::<bool>(&mut __map) {
720 _serde::__private::Ok(__val) => __val,
721 _serde::__private::Err(__err) => {
722 return _serde::__private::Err(__err);
723 }
724 },
725 );
726 }
727 __Field::m_bIsActive0 => {
728 #[cfg(
729 any(feature = "strict", feature = "ignore_duplicates")
730 )]
731 if _serde::__private::Option::is_some(&m_bIsActive0) {
732 #[cfg(feature = "ignore_duplicates")]
733 {
734 __A::skip_value(&mut __map)?;
735 continue;
736 }
737 #[cfg(feature = "strict")]
738 return _serde::__private::Err(
739 <__A::Error as _serde::de::Error>::duplicate_field(
740 "bIsActive0",
741 ),
742 );
743 }
744 m_bIsActive0 = _serde::__private::Some(
745 match __A::next_value::<bool>(&mut __map) {
746 _serde::__private::Ok(__val) => __val,
747 _serde::__private::Err(__err) => {
748 return _serde::__private::Err(__err);
749 }
750 },
751 );
752 }
753 __Field::m_bInvertActive0 => {
754 #[cfg(
755 any(feature = "strict", feature = "ignore_duplicates")
756 )]
757 if _serde::__private::Option::is_some(&m_bInvertActive0) {
758 #[cfg(feature = "ignore_duplicates")]
759 {
760 __A::skip_value(&mut __map)?;
761 continue;
762 }
763 #[cfg(feature = "strict")]
764 return _serde::__private::Err(
765 <__A::Error as _serde::de::Error>::duplicate_field(
766 "bInvertActive0",
767 ),
768 );
769 }
770 m_bInvertActive0 = _serde::__private::Some(
771 match __A::next_value::<bool>(&mut __map) {
772 _serde::__private::Ok(__val) => __val,
773 _serde::__private::Err(__err) => {
774 return _serde::__private::Err(__err);
775 }
776 },
777 );
778 }
779 __Field::m_bIsActive1 => {
780 #[cfg(
781 any(feature = "strict", feature = "ignore_duplicates")
782 )]
783 if _serde::__private::Option::is_some(&m_bIsActive1) {
784 #[cfg(feature = "ignore_duplicates")]
785 {
786 __A::skip_value(&mut __map)?;
787 continue;
788 }
789 #[cfg(feature = "strict")]
790 return _serde::__private::Err(
791 <__A::Error as _serde::de::Error>::duplicate_field(
792 "bIsActive1",
793 ),
794 );
795 }
796 m_bIsActive1 = _serde::__private::Some(
797 match __A::next_value::<bool>(&mut __map) {
798 _serde::__private::Ok(__val) => __val,
799 _serde::__private::Err(__err) => {
800 return _serde::__private::Err(__err);
801 }
802 },
803 );
804 }
805 __Field::m_bInvertActive1 => {
806 #[cfg(
807 any(feature = "strict", feature = "ignore_duplicates")
808 )]
809 if _serde::__private::Option::is_some(&m_bInvertActive1) {
810 #[cfg(feature = "ignore_duplicates")]
811 {
812 __A::skip_value(&mut __map)?;
813 continue;
814 }
815 #[cfg(feature = "strict")]
816 return _serde::__private::Err(
817 <__A::Error as _serde::de::Error>::duplicate_field(
818 "bInvertActive1",
819 ),
820 );
821 }
822 m_bInvertActive1 = _serde::__private::Some(
823 match __A::next_value::<bool>(&mut __map) {
824 _serde::__private::Ok(__val) => __val,
825 _serde::__private::Err(__err) => {
826 return _serde::__private::Err(__err);
827 }
828 },
829 );
830 }
831 __Field::m_bIsActive2 => {
832 #[cfg(
833 any(feature = "strict", feature = "ignore_duplicates")
834 )]
835 if _serde::__private::Option::is_some(&m_bIsActive2) {
836 #[cfg(feature = "ignore_duplicates")]
837 {
838 __A::skip_value(&mut __map)?;
839 continue;
840 }
841 #[cfg(feature = "strict")]
842 return _serde::__private::Err(
843 <__A::Error as _serde::de::Error>::duplicate_field(
844 "bIsActive2",
845 ),
846 );
847 }
848 m_bIsActive2 = _serde::__private::Some(
849 match __A::next_value::<bool>(&mut __map) {
850 _serde::__private::Ok(__val) => __val,
851 _serde::__private::Err(__err) => {
852 return _serde::__private::Err(__err);
853 }
854 },
855 );
856 }
857 __Field::m_bInvertActive2 => {
858 #[cfg(
859 any(feature = "strict", feature = "ignore_duplicates")
860 )]
861 if _serde::__private::Option::is_some(&m_bInvertActive2) {
862 #[cfg(feature = "ignore_duplicates")]
863 {
864 __A::skip_value(&mut __map)?;
865 continue;
866 }
867 #[cfg(feature = "strict")]
868 return _serde::__private::Err(
869 <__A::Error as _serde::de::Error>::duplicate_field(
870 "bInvertActive2",
871 ),
872 );
873 }
874 m_bInvertActive2 = _serde::__private::Some(
875 match __A::next_value::<bool>(&mut __map) {
876 _serde::__private::Ok(__val) => __val,
877 _serde::__private::Err(__err) => {
878 return _serde::__private::Err(__err);
879 }
880 },
881 );
882 }
883 __Field::m_bIsActive3 => {
884 #[cfg(
885 any(feature = "strict", feature = "ignore_duplicates")
886 )]
887 if _serde::__private::Option::is_some(&m_bIsActive3) {
888 #[cfg(feature = "ignore_duplicates")]
889 {
890 __A::skip_value(&mut __map)?;
891 continue;
892 }
893 #[cfg(feature = "strict")]
894 return _serde::__private::Err(
895 <__A::Error as _serde::de::Error>::duplicate_field(
896 "bIsActive3",
897 ),
898 );
899 }
900 m_bIsActive3 = _serde::__private::Some(
901 match __A::next_value::<bool>(&mut __map) {
902 _serde::__private::Ok(__val) => __val,
903 _serde::__private::Err(__err) => {
904 return _serde::__private::Err(__err);
905 }
906 },
907 );
908 }
909 __Field::m_bInvertActive3 => {
910 #[cfg(
911 any(feature = "strict", feature = "ignore_duplicates")
912 )]
913 if _serde::__private::Option::is_some(&m_bInvertActive3) {
914 #[cfg(feature = "ignore_duplicates")]
915 {
916 __A::skip_value(&mut __map)?;
917 continue;
918 }
919 #[cfg(feature = "strict")]
920 return _serde::__private::Err(
921 <__A::Error as _serde::de::Error>::duplicate_field(
922 "bInvertActive3",
923 ),
924 );
925 }
926 m_bInvertActive3 = _serde::__private::Some(
927 match __A::next_value::<bool>(&mut __map) {
928 _serde::__private::Ok(__val) => __val,
929 _serde::__private::Err(__err) => {
930 return _serde::__private::Err(__err);
931 }
932 },
933 );
934 }
935 __Field::m_bIsActive4 => {
936 #[cfg(
937 any(feature = "strict", feature = "ignore_duplicates")
938 )]
939 if _serde::__private::Option::is_some(&m_bIsActive4) {
940 #[cfg(feature = "ignore_duplicates")]
941 {
942 __A::skip_value(&mut __map)?;
943 continue;
944 }
945 #[cfg(feature = "strict")]
946 return _serde::__private::Err(
947 <__A::Error as _serde::de::Error>::duplicate_field(
948 "bIsActive4",
949 ),
950 );
951 }
952 m_bIsActive4 = _serde::__private::Some(
953 match __A::next_value::<bool>(&mut __map) {
954 _serde::__private::Ok(__val) => __val,
955 _serde::__private::Err(__err) => {
956 return _serde::__private::Err(__err);
957 }
958 },
959 );
960 }
961 __Field::m_bInvertActive4 => {
962 #[cfg(
963 any(feature = "strict", feature = "ignore_duplicates")
964 )]
965 if _serde::__private::Option::is_some(&m_bInvertActive4) {
966 #[cfg(feature = "ignore_duplicates")]
967 {
968 __A::skip_value(&mut __map)?;
969 continue;
970 }
971 #[cfg(feature = "strict")]
972 return _serde::__private::Err(
973 <__A::Error as _serde::de::Error>::duplicate_field(
974 "bInvertActive4",
975 ),
976 );
977 }
978 m_bInvertActive4 = _serde::__private::Some(
979 match __A::next_value::<bool>(&mut __map) {
980 _serde::__private::Ok(__val) => __val,
981 _serde::__private::Err(__err) => {
982 return _serde::__private::Err(__err);
983 }
984 },
985 );
986 }
987 _ => __A::skip_value(&mut __map)?,
988 }
989 }
990 let m_variableBindingSet = match m_variableBindingSet {
991 _serde::__private::Some(__field) => __field,
992 _serde::__private::None => {
993 #[cfg(feature = "strict")]
994 return _serde::__private::Err(
995 <__A::Error as _serde::de::Error>::missing_field(
996 "variableBindingSet",
997 ),
998 );
999 #[cfg(not(feature = "strict"))] Default::default()
1000 }
1001 };
1002 let m_userData = match m_userData {
1003 _serde::__private::Some(__field) => __field,
1004 _serde::__private::None => {
1005 #[cfg(feature = "strict")]
1006 return _serde::__private::Err(
1007 <__A::Error as _serde::de::Error>::missing_field("userData"),
1008 );
1009 #[cfg(not(feature = "strict"))] Default::default()
1010 }
1011 };
1012 let m_name = match m_name {
1013 _serde::__private::Some(__field) => __field,
1014 _serde::__private::None => {
1015 #[cfg(feature = "strict")]
1016 return _serde::__private::Err(
1017 <__A::Error as _serde::de::Error>::missing_field("name"),
1018 );
1019 #[cfg(not(feature = "strict"))] Default::default()
1020 }
1021 };
1022 let m_enable = match m_enable {
1023 _serde::__private::Some(__field) => __field,
1024 _serde::__private::None => {
1025 #[cfg(feature = "strict")]
1026 return _serde::__private::Err(
1027 <__A::Error as _serde::de::Error>::missing_field("enable"),
1028 );
1029 #[cfg(not(feature = "strict"))] Default::default()
1030 }
1031 };
1032 let m_bIsActive0 = match m_bIsActive0 {
1033 _serde::__private::Some(__field) => __field,
1034 _serde::__private::None => {
1035 #[cfg(feature = "strict")]
1036 return _serde::__private::Err(
1037 <__A::Error as _serde::de::Error>::missing_field(
1038 "bIsActive0",
1039 ),
1040 );
1041 #[cfg(not(feature = "strict"))] Default::default()
1042 }
1043 };
1044 let m_bInvertActive0 = match m_bInvertActive0 {
1045 _serde::__private::Some(__field) => __field,
1046 _serde::__private::None => {
1047 #[cfg(feature = "strict")]
1048 return _serde::__private::Err(
1049 <__A::Error as _serde::de::Error>::missing_field(
1050 "bInvertActive0",
1051 ),
1052 );
1053 #[cfg(not(feature = "strict"))] Default::default()
1054 }
1055 };
1056 let m_bIsActive1 = match m_bIsActive1 {
1057 _serde::__private::Some(__field) => __field,
1058 _serde::__private::None => {
1059 #[cfg(feature = "strict")]
1060 return _serde::__private::Err(
1061 <__A::Error as _serde::de::Error>::missing_field(
1062 "bIsActive1",
1063 ),
1064 );
1065 #[cfg(not(feature = "strict"))] Default::default()
1066 }
1067 };
1068 let m_bInvertActive1 = match m_bInvertActive1 {
1069 _serde::__private::Some(__field) => __field,
1070 _serde::__private::None => {
1071 #[cfg(feature = "strict")]
1072 return _serde::__private::Err(
1073 <__A::Error as _serde::de::Error>::missing_field(
1074 "bInvertActive1",
1075 ),
1076 );
1077 #[cfg(not(feature = "strict"))] Default::default()
1078 }
1079 };
1080 let m_bIsActive2 = match m_bIsActive2 {
1081 _serde::__private::Some(__field) => __field,
1082 _serde::__private::None => {
1083 #[cfg(feature = "strict")]
1084 return _serde::__private::Err(
1085 <__A::Error as _serde::de::Error>::missing_field(
1086 "bIsActive2",
1087 ),
1088 );
1089 #[cfg(not(feature = "strict"))] Default::default()
1090 }
1091 };
1092 let m_bInvertActive2 = match m_bInvertActive2 {
1093 _serde::__private::Some(__field) => __field,
1094 _serde::__private::None => {
1095 #[cfg(feature = "strict")]
1096 return _serde::__private::Err(
1097 <__A::Error as _serde::de::Error>::missing_field(
1098 "bInvertActive2",
1099 ),
1100 );
1101 #[cfg(not(feature = "strict"))] Default::default()
1102 }
1103 };
1104 let m_bIsActive3 = match m_bIsActive3 {
1105 _serde::__private::Some(__field) => __field,
1106 _serde::__private::None => {
1107 #[cfg(feature = "strict")]
1108 return _serde::__private::Err(
1109 <__A::Error as _serde::de::Error>::missing_field(
1110 "bIsActive3",
1111 ),
1112 );
1113 #[cfg(not(feature = "strict"))] Default::default()
1114 }
1115 };
1116 let m_bInvertActive3 = match m_bInvertActive3 {
1117 _serde::__private::Some(__field) => __field,
1118 _serde::__private::None => {
1119 #[cfg(feature = "strict")]
1120 return _serde::__private::Err(
1121 <__A::Error as _serde::de::Error>::missing_field(
1122 "bInvertActive3",
1123 ),
1124 );
1125 #[cfg(not(feature = "strict"))] Default::default()
1126 }
1127 };
1128 let m_bIsActive4 = match m_bIsActive4 {
1129 _serde::__private::Some(__field) => __field,
1130 _serde::__private::None => {
1131 #[cfg(feature = "strict")]
1132 return _serde::__private::Err(
1133 <__A::Error as _serde::de::Error>::missing_field(
1134 "bIsActive4",
1135 ),
1136 );
1137 #[cfg(not(feature = "strict"))] Default::default()
1138 }
1139 };
1140 let m_bInvertActive4 = match m_bInvertActive4 {
1141 _serde::__private::Some(__field) => __field,
1142 _serde::__private::None => {
1143 #[cfg(feature = "strict")]
1144 return _serde::__private::Err(
1145 <__A::Error as _serde::de::Error>::missing_field(
1146 "bInvertActive4",
1147 ),
1148 );
1149 #[cfg(not(feature = "strict"))] Default::default()
1150 }
1151 };
1152 let __ptr = None;
1153 let parent = hkBaseObject { __ptr };
1154 let parent = hkReferencedObject {
1155 __ptr,
1156 parent,
1157 ..Default::default()
1158 };
1159 let parent = hkbBindable {
1160 __ptr,
1161 parent,
1162 m_variableBindingSet,
1163 ..Default::default()
1164 };
1165 let parent = hkbNode {
1166 __ptr,
1167 parent,
1168 m_userData,
1169 m_name,
1170 ..Default::default()
1171 };
1172 let parent = hkbModifier {
1173 __ptr,
1174 parent,
1175 m_enable,
1176 ..Default::default()
1177 };
1178 let __ptr = __A::class_ptr(&mut __map);
1179 _serde::__private::Ok(BSIsActiveModifier {
1180 __ptr,
1181 parent,
1182 m_bIsActive0,
1183 m_bInvertActive0,
1184 m_bIsActive1,
1185 m_bInvertActive1,
1186 m_bIsActive2,
1187 m_bInvertActive2,
1188 m_bIsActive3,
1189 m_bInvertActive3,
1190 m_bIsActive4,
1191 m_bInvertActive4,
1192 })
1193 }
1194 }
1195 const FIELDS: &[&str] = &[
1196 "bIsActive0",
1197 "bInvertActive0",
1198 "bIsActive1",
1199 "bInvertActive1",
1200 "bIsActive2",
1201 "bInvertActive2",
1202 "bIsActive3",
1203 "bInvertActive3",
1204 "bIsActive4",
1205 "bInvertActive4",
1206 ];
1207 _serde::Deserializer::deserialize_struct(
1208 deserializer,
1209 "BSIsActiveModifier",
1210 FIELDS,
1211 __BSIsActiveModifierVisitor {
1212 marker: _serde::__private::PhantomData::<BSIsActiveModifier>,
1213 lifetime: _serde::__private::PhantomData,
1214 },
1215 )
1216 }
1217 }
1218};