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 BSPassByTargetTriggerModifier<'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 = "targetPosition"))]
36 #[cfg_attr(feature = "serde", serde(rename = "targetPosition"))]
37 pub m_targetPosition: Vector4,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "radius"))]
43 #[cfg_attr(feature = "serde", serde(rename = "radius"))]
44 pub m_radius: f32,
45 #[cfg_attr(feature = "json_schema", schemars(rename = "movementDirection"))]
50 #[cfg_attr(feature = "serde", serde(rename = "movementDirection"))]
51 pub m_movementDirection: Vector4,
52 #[cfg_attr(feature = "json_schema", schemars(rename = "triggerEvent"))]
57 #[cfg_attr(feature = "serde", serde(rename = "triggerEvent"))]
58 pub m_triggerEvent: hkbEventProperty,
59 #[cfg_attr(feature = "json_schema", schemars(rename = "targetPassed"))]
65 #[cfg_attr(feature = "serde", serde(rename = "targetPassed"))]
66 pub m_targetPassed: bool,
67}
68const _: () = {
69 use havok_serde as _serde;
70 impl<'a> _serde::HavokClass for BSPassByTargetTriggerModifier<'a> {
71 #[inline]
72 fn name(&self) -> &'static str {
73 "BSPassByTargetTriggerModifier"
74 }
75 #[inline]
76 fn signature(&self) -> _serde::__private::Signature {
77 _serde::__private::Signature::new(0x703d7b66)
78 }
79 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
80 fn deps_indexes(&self) -> Vec<usize> {
81 let mut v = Vec::new();
82 v.push(self.parent.parent.parent.m_variableBindingSet.get());
83 v.extend(self.m_triggerEvent.deps_indexes());
84 v
85 }
86 }
87 impl<'a> _serde::Serialize for BSPassByTargetTriggerModifier<'a> {
88 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
89 where
90 S: _serde::ser::Serializer,
91 {
92 let class_meta = self
93 .__ptr
94 .map(|name| (name, _serde::__private::Signature::new(0x703d7b66)));
95 let mut serializer = __serializer
96 .serialize_struct(
97 "BSPassByTargetTriggerModifier",
98 class_meta,
99 (112u64, 160u64),
100 )?;
101 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
102 serializer
103 .skip_field(
104 "memSizeAndFlags",
105 &self.parent.parent.parent.parent.m_memSizeAndFlags,
106 )?;
107 serializer
108 .skip_field(
109 "referenceCount",
110 &self.parent.parent.parent.parent.m_referenceCount,
111 )?;
112 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
113 serializer
114 .serialize_field(
115 "variableBindingSet",
116 &self.parent.parent.parent.m_variableBindingSet,
117 )?;
118 serializer
119 .skip_array_field(
120 "cachedBindables",
121 &self.parent.parent.parent.m_cachedBindables,
122 TypeSize::NonPtr,
123 )?;
124 serializer
125 .skip_field(
126 "areBindablesCached",
127 &self.parent.parent.parent.m_areBindablesCached,
128 )?;
129 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
130 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
131 serializer.serialize_field("name", &self.parent.parent.m_name)?;
132 serializer.skip_field("id", &self.parent.parent.m_id)?;
133 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
134 serializer
135 .skip_fixed_array_field(
136 "padNode",
137 self.parent.parent.m_padNode.as_slice(),
138 TypeSize::NonPtr,
139 )?;
140 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
141 serializer.serialize_field("enable", &self.parent.m_enable)?;
142 serializer
143 .skip_fixed_array_field(
144 "padModifier",
145 self.parent.m_padModifier.as_slice(),
146 TypeSize::NonPtr,
147 )?;
148 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
149 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
150 serializer.serialize_field("targetPosition", &self.m_targetPosition)?;
151 serializer.serialize_field("radius", &self.m_radius)?;
152 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 12usize].as_slice())?;
153 serializer.serialize_field("movementDirection", &self.m_movementDirection)?;
154 serializer.serialize_field("triggerEvent", &self.m_triggerEvent)?;
155 serializer.skip_field("targetPassed", &self.m_targetPassed)?;
156 serializer.pad_field([0u8; 7usize].as_slice(), [0u8; 15usize].as_slice())?;
157 serializer.end()
158 }
159 }
160};
161#[doc(hidden)]
162#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
163const _: () = {
164 use havok_serde as _serde;
165 #[automatically_derived]
166 impl<'de> _serde::Deserialize<'de> for BSPassByTargetTriggerModifier<'de> {
167 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
168 where
169 __D: _serde::Deserializer<'de>,
170 {
171 #[allow(non_camel_case_types)]
172 enum __Field {
173 m_variableBindingSet,
174 m_userData,
175 m_name,
176 m_enable,
177 m_targetPosition,
178 m_radius,
179 m_movementDirection,
180 m_triggerEvent,
181 __ignore,
182 }
183 struct __FieldVisitor;
184 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
185 type Value = __Field;
186 fn expecting(
187 &self,
188 __formatter: &mut core::fmt::Formatter,
189 ) -> core::fmt::Result {
190 core::fmt::Formatter::write_str(__formatter, "field identifier")
191 }
192 #[allow(clippy::match_single_binding)]
194 #[allow(clippy::reversed_empty_ranges)]
195 #[allow(clippy::single_match)]
196 fn visit_key<__E>(
197 self,
198 __value: &str,
199 ) -> core::result::Result<Self::Value, __E>
200 where
201 __E: _serde::de::Error,
202 {
203 match __value {
204 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
205 "userData" => Ok(__Field::m_userData),
206 "name" => Ok(__Field::m_name),
207 "enable" => Ok(__Field::m_enable),
208 "targetPosition" => Ok(__Field::m_targetPosition),
209 "radius" => Ok(__Field::m_radius),
210 "movementDirection" => Ok(__Field::m_movementDirection),
211 "triggerEvent" => Ok(__Field::m_triggerEvent),
212 _ => Ok(__Field::__ignore),
213 }
214 }
215 }
216 impl<'de> _serde::Deserialize<'de> for __Field {
217 #[inline]
218 fn deserialize<__D>(
219 __deserializer: __D,
220 ) -> core::result::Result<Self, __D::Error>
221 where
222 __D: _serde::Deserializer<'de>,
223 {
224 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
225 }
226 }
227 struct __BSPassByTargetTriggerModifierVisitor<'de> {
228 marker: _serde::__private::PhantomData<
229 BSPassByTargetTriggerModifier<'de>,
230 >,
231 lifetime: _serde::__private::PhantomData<&'de ()>,
232 }
233 #[allow(clippy::match_single_binding)]
234 #[allow(clippy::reversed_empty_ranges)]
235 #[allow(clippy::single_match)]
236 impl<'de> _serde::de::Visitor<'de>
237 for __BSPassByTargetTriggerModifierVisitor<'de> {
238 type Value = BSPassByTargetTriggerModifier<'de>;
239 fn expecting(
240 &self,
241 __formatter: &mut core::fmt::Formatter,
242 ) -> core::fmt::Result {
243 core::fmt::Formatter::write_str(
244 __formatter,
245 "struct BSPassByTargetTriggerModifier",
246 )
247 }
248 fn visit_struct_for_bytes<__A>(
249 self,
250 mut __map: __A,
251 ) -> _serde::__private::Result<Self::Value, __A::Error>
252 where
253 __A: _serde::de::MapAccess<'de>,
254 {
255 let __ptr = __A::class_ptr(&mut __map);
256 let parent = __A::parent_value(&mut __map)?;
257 let mut m_targetPosition: _serde::__private::Option<Vector4> = _serde::__private::None;
258 let mut m_radius: _serde::__private::Option<f32> = _serde::__private::None;
259 let mut m_movementDirection: _serde::__private::Option<Vector4> = _serde::__private::None;
260 let mut m_triggerEvent: _serde::__private::Option<
261 hkbEventProperty,
262 > = _serde::__private::None;
263 let mut m_targetPassed: _serde::__private::Option<bool> = _serde::__private::None;
264 for i in 0..5usize {
265 match i {
266 0usize => {
267 if _serde::__private::Option::is_some(&m_targetPosition) {
268 return _serde::__private::Err(
269 <__A::Error as _serde::de::Error>::duplicate_field(
270 "targetPosition",
271 ),
272 );
273 }
274 __A::pad(&mut __map, 4usize, 0usize)?;
275 m_targetPosition = _serde::__private::Some(
276 match __A::next_value::<Vector4>(&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_radius) {
286 return _serde::__private::Err(
287 <__A::Error as _serde::de::Error>::duplicate_field("radius"),
288 );
289 }
290 m_radius = _serde::__private::Some(
291 match __A::next_value::<f32>(&mut __map) {
292 _serde::__private::Ok(__val) => __val,
293 _serde::__private::Err(__err) => {
294 return _serde::__private::Err(__err);
295 }
296 },
297 );
298 }
299 2usize => {
300 if _serde::__private::Option::is_some(
301 &m_movementDirection,
302 ) {
303 return _serde::__private::Err(
304 <__A::Error as _serde::de::Error>::duplicate_field(
305 "movementDirection",
306 ),
307 );
308 }
309 __A::pad(&mut __map, 12usize, 12usize)?;
310 m_movementDirection = _serde::__private::Some(
311 match __A::next_value::<Vector4>(&mut __map) {
312 _serde::__private::Ok(__val) => __val,
313 _serde::__private::Err(__err) => {
314 return _serde::__private::Err(__err);
315 }
316 },
317 );
318 }
319 3usize => {
320 if _serde::__private::Option::is_some(&m_triggerEvent) {
321 return _serde::__private::Err(
322 <__A::Error as _serde::de::Error>::duplicate_field(
323 "triggerEvent",
324 ),
325 );
326 }
327 m_triggerEvent = _serde::__private::Some(
328 match __A::next_value::<hkbEventProperty>(&mut __map) {
329 _serde::__private::Ok(__val) => __val,
330 _serde::__private::Err(__err) => {
331 return _serde::__private::Err(__err);
332 }
333 },
334 );
335 }
336 4usize => {
337 if _serde::__private::Option::is_some(&m_targetPassed) {
338 return _serde::__private::Err(
339 <__A::Error as _serde::de::Error>::duplicate_field(
340 "targetPassed",
341 ),
342 );
343 }
344 m_targetPassed = _serde::__private::Some(
345 match __A::next_value::<bool>(&mut __map) {
346 _serde::__private::Ok(__val) => __val,
347 _serde::__private::Err(__err) => {
348 return _serde::__private::Err(__err);
349 }
350 },
351 );
352 }
353 _ => {}
354 }
355 }
356 __A::pad(&mut __map, 7usize, 15usize)?;
357 let m_targetPosition = match m_targetPosition {
358 _serde::__private::Some(__field) => __field,
359 _serde::__private::None => {
360 return _serde::__private::Err(
361 <__A::Error as _serde::de::Error>::missing_field(
362 "targetPosition",
363 ),
364 );
365 }
366 };
367 let m_radius = match m_radius {
368 _serde::__private::Some(__field) => __field,
369 _serde::__private::None => {
370 return _serde::__private::Err(
371 <__A::Error as _serde::de::Error>::missing_field("radius"),
372 );
373 }
374 };
375 let m_movementDirection = match m_movementDirection {
376 _serde::__private::Some(__field) => __field,
377 _serde::__private::None => {
378 return _serde::__private::Err(
379 <__A::Error as _serde::de::Error>::missing_field(
380 "movementDirection",
381 ),
382 );
383 }
384 };
385 let m_triggerEvent = match m_triggerEvent {
386 _serde::__private::Some(__field) => __field,
387 _serde::__private::None => {
388 return _serde::__private::Err(
389 <__A::Error as _serde::de::Error>::missing_field(
390 "triggerEvent",
391 ),
392 );
393 }
394 };
395 let m_targetPassed = match m_targetPassed {
396 _serde::__private::Some(__field) => __field,
397 _serde::__private::None => {
398 return _serde::__private::Err(
399 <__A::Error as _serde::de::Error>::missing_field(
400 "targetPassed",
401 ),
402 );
403 }
404 };
405 _serde::__private::Ok(BSPassByTargetTriggerModifier {
406 __ptr,
407 parent,
408 m_targetPosition,
409 m_radius,
410 m_movementDirection,
411 m_triggerEvent,
412 m_targetPassed,
413 })
414 }
415 #[allow(clippy::manual_unwrap_or_default)]
416 fn visit_struct<__A>(
417 self,
418 mut __map: __A,
419 ) -> _serde::__private::Result<Self::Value, __A::Error>
420 where
421 __A: _serde::de::MapAccess<'de>,
422 {
423 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
424 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
425 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
426 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
427 let mut m_targetPosition: _serde::__private::Option<Vector4> = _serde::__private::None;
428 let mut m_radius: _serde::__private::Option<f32> = _serde::__private::None;
429 let mut m_movementDirection: _serde::__private::Option<Vector4> = _serde::__private::None;
430 let mut m_triggerEvent: _serde::__private::Option<
431 hkbEventProperty,
432 > = _serde::__private::None;
433 while let _serde::__private::Some(__key) = {
434 __A::next_key::<__Field>(&mut __map)?
435 } {
436 match __key {
437 __Field::m_variableBindingSet => {
438 #[cfg(
439 any(feature = "strict", feature = "ignore_duplicates")
440 )]
441 if _serde::__private::Option::is_some(
442 &m_variableBindingSet,
443 ) {
444 #[cfg(feature = "ignore_duplicates")]
445 {
446 __A::skip_value(&mut __map)?;
447 continue;
448 }
449 #[cfg(feature = "strict")]
450 return _serde::__private::Err(
451 <__A::Error as _serde::de::Error>::duplicate_field(
452 "variableBindingSet",
453 ),
454 );
455 }
456 m_variableBindingSet = _serde::__private::Some(
457 match __A::next_value::<Pointer>(&mut __map) {
458 _serde::__private::Ok(__val) => __val,
459 _serde::__private::Err(__err) => {
460 return _serde::__private::Err(__err);
461 }
462 },
463 );
464 }
465 __Field::m_userData => {
466 #[cfg(
467 any(feature = "strict", feature = "ignore_duplicates")
468 )]
469 if _serde::__private::Option::is_some(&m_userData) {
470 #[cfg(feature = "ignore_duplicates")]
471 {
472 __A::skip_value(&mut __map)?;
473 continue;
474 }
475 #[cfg(feature = "strict")]
476 return _serde::__private::Err(
477 <__A::Error as _serde::de::Error>::duplicate_field(
478 "userData",
479 ),
480 );
481 }
482 m_userData = _serde::__private::Some(
483 match __A::next_value::<Ulong>(&mut __map) {
484 _serde::__private::Ok(__val) => __val,
485 _serde::__private::Err(__err) => {
486 return _serde::__private::Err(__err);
487 }
488 },
489 );
490 }
491 __Field::m_name => {
492 #[cfg(
493 any(feature = "strict", feature = "ignore_duplicates")
494 )]
495 if _serde::__private::Option::is_some(&m_name) {
496 #[cfg(feature = "ignore_duplicates")]
497 {
498 __A::skip_value(&mut __map)?;
499 continue;
500 }
501 #[cfg(feature = "strict")]
502 return _serde::__private::Err(
503 <__A::Error as _serde::de::Error>::duplicate_field("name"),
504 );
505 }
506 m_name = _serde::__private::Some(
507 match __A::next_value::<StringPtr<'de>>(&mut __map) {
508 _serde::__private::Ok(__val) => __val,
509 _serde::__private::Err(__err) => {
510 return _serde::__private::Err(__err);
511 }
512 },
513 );
514 }
515 __Field::m_enable => {
516 #[cfg(
517 any(feature = "strict", feature = "ignore_duplicates")
518 )]
519 if _serde::__private::Option::is_some(&m_enable) {
520 #[cfg(feature = "ignore_duplicates")]
521 {
522 __A::skip_value(&mut __map)?;
523 continue;
524 }
525 #[cfg(feature = "strict")]
526 return _serde::__private::Err(
527 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
528 );
529 }
530 m_enable = _serde::__private::Some(
531 match __A::next_value::<bool>(&mut __map) {
532 _serde::__private::Ok(__val) => __val,
533 _serde::__private::Err(__err) => {
534 return _serde::__private::Err(__err);
535 }
536 },
537 );
538 }
539 __Field::m_targetPosition => {
540 #[cfg(
541 any(feature = "strict", feature = "ignore_duplicates")
542 )]
543 if _serde::__private::Option::is_some(&m_targetPosition) {
544 #[cfg(feature = "ignore_duplicates")]
545 {
546 __A::skip_value(&mut __map)?;
547 continue;
548 }
549 #[cfg(feature = "strict")]
550 return _serde::__private::Err(
551 <__A::Error as _serde::de::Error>::duplicate_field(
552 "targetPosition",
553 ),
554 );
555 }
556 m_targetPosition = _serde::__private::Some(
557 match __A::next_value::<Vector4>(&mut __map) {
558 _serde::__private::Ok(__val) => __val,
559 _serde::__private::Err(__err) => {
560 return _serde::__private::Err(__err);
561 }
562 },
563 );
564 }
565 __Field::m_radius => {
566 #[cfg(
567 any(feature = "strict", feature = "ignore_duplicates")
568 )]
569 if _serde::__private::Option::is_some(&m_radius) {
570 #[cfg(feature = "ignore_duplicates")]
571 {
572 __A::skip_value(&mut __map)?;
573 continue;
574 }
575 #[cfg(feature = "strict")]
576 return _serde::__private::Err(
577 <__A::Error as _serde::de::Error>::duplicate_field("radius"),
578 );
579 }
580 m_radius = _serde::__private::Some(
581 match __A::next_value::<f32>(&mut __map) {
582 _serde::__private::Ok(__val) => __val,
583 _serde::__private::Err(__err) => {
584 return _serde::__private::Err(__err);
585 }
586 },
587 );
588 }
589 __Field::m_movementDirection => {
590 #[cfg(
591 any(feature = "strict", feature = "ignore_duplicates")
592 )]
593 if _serde::__private::Option::is_some(
594 &m_movementDirection,
595 ) {
596 #[cfg(feature = "ignore_duplicates")]
597 {
598 __A::skip_value(&mut __map)?;
599 continue;
600 }
601 #[cfg(feature = "strict")]
602 return _serde::__private::Err(
603 <__A::Error as _serde::de::Error>::duplicate_field(
604 "movementDirection",
605 ),
606 );
607 }
608 m_movementDirection = _serde::__private::Some(
609 match __A::next_value::<Vector4>(&mut __map) {
610 _serde::__private::Ok(__val) => __val,
611 _serde::__private::Err(__err) => {
612 return _serde::__private::Err(__err);
613 }
614 },
615 );
616 }
617 __Field::m_triggerEvent => {
618 #[cfg(
619 any(feature = "strict", feature = "ignore_duplicates")
620 )]
621 if _serde::__private::Option::is_some(&m_triggerEvent) {
622 #[cfg(feature = "ignore_duplicates")]
623 {
624 __A::skip_value(&mut __map)?;
625 continue;
626 }
627 #[cfg(feature = "strict")]
628 return _serde::__private::Err(
629 <__A::Error as _serde::de::Error>::duplicate_field(
630 "triggerEvent",
631 ),
632 );
633 }
634 m_triggerEvent = _serde::__private::Some(
635 match __A::next_value::<hkbEventProperty>(&mut __map) {
636 _serde::__private::Ok(__val) => __val,
637 _serde::__private::Err(__err) => {
638 return _serde::__private::Err(__err);
639 }
640 },
641 );
642 }
643 _ => __A::skip_value(&mut __map)?,
644 }
645 }
646 let m_variableBindingSet = match m_variableBindingSet {
647 _serde::__private::Some(__field) => __field,
648 _serde::__private::None => {
649 #[cfg(feature = "strict")]
650 return _serde::__private::Err(
651 <__A::Error as _serde::de::Error>::missing_field(
652 "variableBindingSet",
653 ),
654 );
655 #[cfg(not(feature = "strict"))] Default::default()
656 }
657 };
658 let m_userData = match m_userData {
659 _serde::__private::Some(__field) => __field,
660 _serde::__private::None => {
661 #[cfg(feature = "strict")]
662 return _serde::__private::Err(
663 <__A::Error as _serde::de::Error>::missing_field("userData"),
664 );
665 #[cfg(not(feature = "strict"))] Default::default()
666 }
667 };
668 let m_name = match m_name {
669 _serde::__private::Some(__field) => __field,
670 _serde::__private::None => {
671 #[cfg(feature = "strict")]
672 return _serde::__private::Err(
673 <__A::Error as _serde::de::Error>::missing_field("name"),
674 );
675 #[cfg(not(feature = "strict"))] Default::default()
676 }
677 };
678 let m_enable = match m_enable {
679 _serde::__private::Some(__field) => __field,
680 _serde::__private::None => {
681 #[cfg(feature = "strict")]
682 return _serde::__private::Err(
683 <__A::Error as _serde::de::Error>::missing_field("enable"),
684 );
685 #[cfg(not(feature = "strict"))] Default::default()
686 }
687 };
688 let m_targetPosition = match m_targetPosition {
689 _serde::__private::Some(__field) => __field,
690 _serde::__private::None => {
691 #[cfg(feature = "strict")]
692 return _serde::__private::Err(
693 <__A::Error as _serde::de::Error>::missing_field(
694 "targetPosition",
695 ),
696 );
697 #[cfg(not(feature = "strict"))] Default::default()
698 }
699 };
700 let m_radius = match m_radius {
701 _serde::__private::Some(__field) => __field,
702 _serde::__private::None => {
703 #[cfg(feature = "strict")]
704 return _serde::__private::Err(
705 <__A::Error as _serde::de::Error>::missing_field("radius"),
706 );
707 #[cfg(not(feature = "strict"))] Default::default()
708 }
709 };
710 let m_movementDirection = match m_movementDirection {
711 _serde::__private::Some(__field) => __field,
712 _serde::__private::None => {
713 #[cfg(feature = "strict")]
714 return _serde::__private::Err(
715 <__A::Error as _serde::de::Error>::missing_field(
716 "movementDirection",
717 ),
718 );
719 #[cfg(not(feature = "strict"))] Default::default()
720 }
721 };
722 let m_triggerEvent = match m_triggerEvent {
723 _serde::__private::Some(__field) => __field,
724 _serde::__private::None => {
725 #[cfg(feature = "strict")]
726 return _serde::__private::Err(
727 <__A::Error as _serde::de::Error>::missing_field(
728 "triggerEvent",
729 ),
730 );
731 #[cfg(not(feature = "strict"))] Default::default()
732 }
733 };
734 let __ptr = None;
735 let parent = hkBaseObject { __ptr };
736 let parent = hkReferencedObject {
737 __ptr,
738 parent,
739 ..Default::default()
740 };
741 let parent = hkbBindable {
742 __ptr,
743 parent,
744 m_variableBindingSet,
745 ..Default::default()
746 };
747 let parent = hkbNode {
748 __ptr,
749 parent,
750 m_userData,
751 m_name,
752 ..Default::default()
753 };
754 let parent = hkbModifier {
755 __ptr,
756 parent,
757 m_enable,
758 ..Default::default()
759 };
760 let __ptr = __A::class_ptr(&mut __map);
761 _serde::__private::Ok(BSPassByTargetTriggerModifier {
762 __ptr,
763 parent,
764 m_targetPosition,
765 m_radius,
766 m_movementDirection,
767 m_triggerEvent,
768 ..Default::default()
769 })
770 }
771 }
772 const FIELDS: &[&str] = &[
773 "targetPosition",
774 "radius",
775 "movementDirection",
776 "triggerEvent",
777 "targetPassed",
778 ];
779 _serde::Deserializer::deserialize_struct(
780 deserializer,
781 "BSPassByTargetTriggerModifier",
782 FIELDS,
783 __BSPassByTargetTriggerModifierVisitor {
784 marker: _serde::__private::PhantomData::<
785 BSPassByTargetTriggerModifier,
786 >,
787 lifetime: _serde::__private::PhantomData,
788 },
789 )
790 }
791 }
792};