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