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