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 hkbEventRangeData {
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(rename = "upperBound"))]
31 #[cfg_attr(feature = "serde", serde(rename = "upperBound"))]
32 pub m_upperBound: f32,
33 #[cfg_attr(feature = "json_schema", schemars(rename = "event"))]
38 #[cfg_attr(feature = "serde", serde(rename = "event"))]
39 pub m_event: hkbEventProperty,
40 #[cfg_attr(feature = "json_schema", schemars(rename = "eventMode"))]
45 #[cfg_attr(feature = "serde", serde(rename = "eventMode"))]
46 pub m_eventMode: EventRangeMode,
47}
48const _: () = {
49 use havok_serde as _serde;
50 impl _serde::HavokClass for hkbEventRangeData {
51 #[inline]
52 fn name(&self) -> &'static str {
53 "hkbEventRangeData"
54 }
55 #[inline]
56 fn signature(&self) -> _serde::__private::Signature {
57 _serde::__private::Signature::new(0x6cb92c76)
58 }
59 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
60 fn deps_indexes(&self) -> Vec<usize> {
61 let mut v = Vec::new();
62 v.extend(self.m_event.deps_indexes());
63 v
64 }
65 }
66 impl _serde::Serialize for hkbEventRangeData {
67 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
68 where
69 S: _serde::ser::Serializer,
70 {
71 let class_meta = self
72 .__ptr
73 .map(|name| (name, _serde::__private::Signature::new(0x6cb92c76)));
74 let mut serializer = __serializer
75 .serialize_struct("hkbEventRangeData", class_meta, (16u64, 32u64))?;
76 serializer.serialize_field("upperBound", &self.m_upperBound)?;
77 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
78 serializer.serialize_field("event", &self.m_event)?;
79 serializer.serialize_field("eventMode", &self.m_eventMode)?;
80 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
81 serializer.end()
82 }
83 }
84};
85#[doc(hidden)]
86#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
87const _: () = {
88 use havok_serde as _serde;
89 #[automatically_derived]
90 impl<'de> _serde::Deserialize<'de> for hkbEventRangeData {
91 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
92 where
93 __D: _serde::Deserializer<'de>,
94 {
95 #[allow(non_camel_case_types)]
96 enum __Field {
97 m_upperBound,
98 m_event,
99 m_eventMode,
100 __ignore,
101 }
102 struct __FieldVisitor;
103 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
104 type Value = __Field;
105 fn expecting(
106 &self,
107 __formatter: &mut core::fmt::Formatter,
108 ) -> core::fmt::Result {
109 core::fmt::Formatter::write_str(__formatter, "field identifier")
110 }
111 #[allow(clippy::match_single_binding)]
113 #[allow(clippy::reversed_empty_ranges)]
114 #[allow(clippy::single_match)]
115 fn visit_key<__E>(
116 self,
117 __value: &str,
118 ) -> core::result::Result<Self::Value, __E>
119 where
120 __E: _serde::de::Error,
121 {
122 match __value {
123 "upperBound" => Ok(__Field::m_upperBound),
124 "event" => Ok(__Field::m_event),
125 "eventMode" => Ok(__Field::m_eventMode),
126 _ => Ok(__Field::__ignore),
127 }
128 }
129 }
130 impl<'de> _serde::Deserialize<'de> for __Field {
131 #[inline]
132 fn deserialize<__D>(
133 __deserializer: __D,
134 ) -> core::result::Result<Self, __D::Error>
135 where
136 __D: _serde::Deserializer<'de>,
137 {
138 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
139 }
140 }
141 struct __hkbEventRangeDataVisitor<'de> {
142 marker: _serde::__private::PhantomData<hkbEventRangeData>,
143 lifetime: _serde::__private::PhantomData<&'de ()>,
144 }
145 #[allow(clippy::match_single_binding)]
146 #[allow(clippy::reversed_empty_ranges)]
147 #[allow(clippy::single_match)]
148 impl<'de> _serde::de::Visitor<'de> for __hkbEventRangeDataVisitor<'de> {
149 type Value = hkbEventRangeData;
150 fn expecting(
151 &self,
152 __formatter: &mut core::fmt::Formatter,
153 ) -> core::fmt::Result {
154 core::fmt::Formatter::write_str(
155 __formatter,
156 "struct hkbEventRangeData",
157 )
158 }
159 fn visit_struct_for_bytes<__A>(
160 self,
161 mut __map: __A,
162 ) -> _serde::__private::Result<Self::Value, __A::Error>
163 where
164 __A: _serde::de::MapAccess<'de>,
165 {
166 let __ptr = __A::class_ptr(&mut __map);
167 let mut m_upperBound: _serde::__private::Option<f32> = _serde::__private::None;
168 let mut m_event: _serde::__private::Option<hkbEventProperty> = _serde::__private::None;
169 let mut m_eventMode: _serde::__private::Option<EventRangeMode> = _serde::__private::None;
170 for i in 0..3usize {
171 match i {
172 0usize => {
173 if _serde::__private::Option::is_some(&m_upperBound) {
174 return _serde::__private::Err(
175 <__A::Error as _serde::de::Error>::duplicate_field(
176 "upperBound",
177 ),
178 );
179 }
180 m_upperBound = _serde::__private::Some(
181 match __A::next_value::<f32>(&mut __map) {
182 _serde::__private::Ok(__val) => __val,
183 _serde::__private::Err(__err) => {
184 return _serde::__private::Err(__err);
185 }
186 },
187 );
188 }
189 1usize => {
190 if _serde::__private::Option::is_some(&m_event) {
191 return _serde::__private::Err(
192 <__A::Error as _serde::de::Error>::duplicate_field("event"),
193 );
194 }
195 __A::pad(&mut __map, 0usize, 4usize)?;
196 m_event = _serde::__private::Some(
197 match __A::next_value::<hkbEventProperty>(&mut __map) {
198 _serde::__private::Ok(__val) => __val,
199 _serde::__private::Err(__err) => {
200 return _serde::__private::Err(__err);
201 }
202 },
203 );
204 }
205 2usize => {
206 if _serde::__private::Option::is_some(&m_eventMode) {
207 return _serde::__private::Err(
208 <__A::Error as _serde::de::Error>::duplicate_field(
209 "eventMode",
210 ),
211 );
212 }
213 m_eventMode = _serde::__private::Some(
214 match __A::next_value::<EventRangeMode>(&mut __map) {
215 _serde::__private::Ok(__val) => __val,
216 _serde::__private::Err(__err) => {
217 return _serde::__private::Err(__err);
218 }
219 },
220 );
221 }
222 _ => {}
223 }
224 }
225 __A::pad(&mut __map, 3usize, 7usize)?;
226 let m_upperBound = match m_upperBound {
227 _serde::__private::Some(__field) => __field,
228 _serde::__private::None => {
229 return _serde::__private::Err(
230 <__A::Error as _serde::de::Error>::missing_field(
231 "upperBound",
232 ),
233 );
234 }
235 };
236 let m_event = match m_event {
237 _serde::__private::Some(__field) => __field,
238 _serde::__private::None => {
239 return _serde::__private::Err(
240 <__A::Error as _serde::de::Error>::missing_field("event"),
241 );
242 }
243 };
244 let m_eventMode = match m_eventMode {
245 _serde::__private::Some(__field) => __field,
246 _serde::__private::None => {
247 return _serde::__private::Err(
248 <__A::Error as _serde::de::Error>::missing_field(
249 "eventMode",
250 ),
251 );
252 }
253 };
254 _serde::__private::Ok(hkbEventRangeData {
255 __ptr,
256 m_upperBound,
257 m_event,
258 m_eventMode,
259 })
260 }
261 #[allow(clippy::manual_unwrap_or_default)]
262 fn visit_struct<__A>(
263 self,
264 mut __map: __A,
265 ) -> _serde::__private::Result<Self::Value, __A::Error>
266 where
267 __A: _serde::de::MapAccess<'de>,
268 {
269 let mut m_upperBound: _serde::__private::Option<f32> = _serde::__private::None;
270 let mut m_event: _serde::__private::Option<hkbEventProperty> = _serde::__private::None;
271 let mut m_eventMode: _serde::__private::Option<EventRangeMode> = _serde::__private::None;
272 while let _serde::__private::Some(__key) = {
273 __A::next_key::<__Field>(&mut __map)?
274 } {
275 match __key {
276 __Field::m_upperBound => {
277 #[cfg(
278 any(feature = "strict", feature = "ignore_duplicates")
279 )]
280 if _serde::__private::Option::is_some(&m_upperBound) {
281 #[cfg(feature = "ignore_duplicates")]
282 {
283 __A::skip_value(&mut __map)?;
284 continue;
285 }
286 #[cfg(feature = "strict")]
287 return _serde::__private::Err(
288 <__A::Error as _serde::de::Error>::duplicate_field(
289 "upperBound",
290 ),
291 );
292 }
293 m_upperBound = _serde::__private::Some(
294 match __A::next_value::<f32>(&mut __map) {
295 _serde::__private::Ok(__val) => __val,
296 _serde::__private::Err(__err) => {
297 return _serde::__private::Err(__err);
298 }
299 },
300 );
301 }
302 __Field::m_event => {
303 #[cfg(
304 any(feature = "strict", feature = "ignore_duplicates")
305 )]
306 if _serde::__private::Option::is_some(&m_event) {
307 #[cfg(feature = "ignore_duplicates")]
308 {
309 __A::skip_value(&mut __map)?;
310 continue;
311 }
312 #[cfg(feature = "strict")]
313 return _serde::__private::Err(
314 <__A::Error as _serde::de::Error>::duplicate_field("event"),
315 );
316 }
317 m_event = _serde::__private::Some(
318 match __A::next_value::<hkbEventProperty>(&mut __map) {
319 _serde::__private::Ok(__val) => __val,
320 _serde::__private::Err(__err) => {
321 return _serde::__private::Err(__err);
322 }
323 },
324 );
325 }
326 __Field::m_eventMode => {
327 #[cfg(
328 any(feature = "strict", feature = "ignore_duplicates")
329 )]
330 if _serde::__private::Option::is_some(&m_eventMode) {
331 #[cfg(feature = "ignore_duplicates")]
332 {
333 __A::skip_value(&mut __map)?;
334 continue;
335 }
336 #[cfg(feature = "strict")]
337 return _serde::__private::Err(
338 <__A::Error as _serde::de::Error>::duplicate_field(
339 "eventMode",
340 ),
341 );
342 }
343 m_eventMode = _serde::__private::Some(
344 match __A::next_value::<EventRangeMode>(&mut __map) {
345 _serde::__private::Ok(__val) => __val,
346 _serde::__private::Err(__err) => {
347 return _serde::__private::Err(__err);
348 }
349 },
350 );
351 }
352 _ => __A::skip_value(&mut __map)?,
353 }
354 }
355 let m_upperBound = match m_upperBound {
356 _serde::__private::Some(__field) => __field,
357 _serde::__private::None => {
358 #[cfg(feature = "strict")]
359 return _serde::__private::Err(
360 <__A::Error as _serde::de::Error>::missing_field(
361 "upperBound",
362 ),
363 );
364 #[cfg(not(feature = "strict"))] Default::default()
365 }
366 };
367 let m_event = match m_event {
368 _serde::__private::Some(__field) => __field,
369 _serde::__private::None => {
370 #[cfg(feature = "strict")]
371 return _serde::__private::Err(
372 <__A::Error as _serde::de::Error>::missing_field("event"),
373 );
374 #[cfg(not(feature = "strict"))] Default::default()
375 }
376 };
377 let m_eventMode = match m_eventMode {
378 _serde::__private::Some(__field) => __field,
379 _serde::__private::None => {
380 #[cfg(feature = "strict")]
381 return _serde::__private::Err(
382 <__A::Error as _serde::de::Error>::missing_field(
383 "eventMode",
384 ),
385 );
386 #[cfg(not(feature = "strict"))] Default::default()
387 }
388 };
389 let __ptr = __A::class_ptr(&mut __map);
390 _serde::__private::Ok(hkbEventRangeData {
391 __ptr,
392 m_upperBound,
393 m_event,
394 m_eventMode,
395 })
396 }
397 }
398 const FIELDS: &[&str] = &["upperBound", "event", "eventMode"];
399 _serde::Deserializer::deserialize_struct(
400 deserializer,
401 "hkbEventRangeData",
402 FIELDS,
403 __hkbEventRangeDataVisitor {
404 marker: _serde::__private::PhantomData::<hkbEventRangeData>,
405 lifetime: _serde::__private::PhantomData,
406 },
407 )
408 }
409 }
410};
411#[allow(non_upper_case_globals, non_snake_case)]
414#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
415#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
416#[derive(
417 Debug,
418 Clone,
419 Default,
420 PartialEq,
421 Eq,
422 PartialOrd,
423 Ord,
424 num_derive::ToPrimitive,
425 num_derive::FromPrimitive,
426)]
427pub enum EventRangeMode {
428 #[default]
429 EVENT_MODE_SEND_ON_ENTER_RANGE = 0isize,
430 EVENT_MODE_SEND_WHEN_IN_RANGE = 1isize,
431}
432const _: () = {
433 use havok_serde as __serde;
434 impl __serde::Serialize for EventRangeMode {
435 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
436 where
437 S: __serde::ser::Serializer,
438 {
439 let mut __serializer = __serializer.serialize_enum_flags()?;
440 match self {
441 Self::EVENT_MODE_SEND_ON_ENTER_RANGE => {
442 __serializer.serialize_field("EVENT_MODE_SEND_ON_ENTER_RANGE", &0u64)
443 }
444 Self::EVENT_MODE_SEND_WHEN_IN_RANGE => {
445 __serializer.serialize_field("EVENT_MODE_SEND_WHEN_IN_RANGE", &1u64)
446 }
447 }?;
448 use num_traits::ToPrimitive as _;
449 let num = self
450 .to_i8()
451 .ok_or(S::Error::custom("Failed enum EventRangeMode to_i8"))?;
452 __serializer.serialize_bits(&num)?;
453 __serializer.end()
454 }
455 }
456};
457#[doc(hidden)]
458#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
459const _: () = {
460 #[allow(unused_extern_crates, clippy::useless_attribute)]
461 extern crate havok_serde as _serde;
462 #[automatically_derived]
463 impl<'de> _serde::Deserialize<'de> for EventRangeMode {
464 fn deserialize<__D>(
465 __deserializer: __D,
466 ) -> _serde::__private::Result<Self, __D::Error>
467 where
468 __D: _serde::Deserializer<'de>,
469 {
470 #[allow(non_camel_case_types)]
471 #[doc(hidden)]
472 enum __Field {
473 __field0,
474 __field1,
475 }
476 #[doc(hidden)]
477 struct __FieldVisitor;
478 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
479 type Value = __Field;
480 fn expecting(
481 &self,
482 __formatter: &mut _serde::__private::Formatter,
483 ) -> _serde::__private::fmt::Result {
484 _serde::__private::Formatter::write_str(
485 __formatter,
486 "variant identifier",
487 )
488 }
489 fn visit_int8<__E>(
490 self,
491 __value: i8,
492 ) -> _serde::__private::Result<Self::Value, __E>
493 where
494 __E: _serde::de::Error,
495 {
496 match __value {
497 0i8 => _serde::__private::Ok(__Field::__field0),
498 1i8 => _serde::__private::Ok(__Field::__field1),
499 _ => {
500 _serde::__private::Err(
501 _serde::de::Error::invalid_value(
502 _serde::de::Unexpected::Int8(__value),
503 &"value(i8) of variant is one of 0, 1",
504 ),
505 )
506 }
507 }
508 }
509 fn visit_stringptr<__E>(
510 self,
511 __value: StringPtr<'de>,
512 ) -> _serde::__private::Result<Self::Value, __E>
513 where
514 __E: _serde::de::Error,
515 {
516 if let Some(__value) = __value.into_inner() {
517 match __value.as_ref() {
518 v if v == "0"
519 || v
520 .eq_ignore_ascii_case("EVENT_MODE_SEND_ON_ENTER_RANGE") => {
521 _serde::__private::Ok(__Field::__field0)
522 }
523 v if v == "1"
524 || v
525 .eq_ignore_ascii_case("EVENT_MODE_SEND_WHEN_IN_RANGE") => {
526 _serde::__private::Ok(__Field::__field1)
527 }
528 _ => {
529 _serde::__private::Err(
530 _serde::de::Error::unknown_variant(&__value, VARIANTS),
531 )
532 }
533 }
534 } else {
535 _serde::__private::Err(
536 _serde::de::Error::unknown_variant("None", VARIANTS),
537 )
538 }
539 }
540 }
541 impl<'de> _serde::Deserialize<'de> for __Field {
542 #[inline]
543 fn deserialize<__D>(
544 __deserializer: __D,
545 ) -> _serde::__private::Result<Self, __D::Error>
546 where
547 __D: _serde::Deserializer<'de>,
548 {
549 _serde::Deserializer::deserialize_identifier(
550 __deserializer,
551 _serde::de::ReadEnumSize::Int8,
552 __FieldVisitor,
553 )
554 }
555 }
556 #[doc(hidden)]
557 struct __Visitor<'de> {
558 marker: _serde::__private::PhantomData<EventRangeMode>,
559 lifetime: _serde::__private::PhantomData<&'de ()>,
560 }
561 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
562 type Value = EventRangeMode;
563 fn expecting(
564 &self,
565 __formatter: &mut _serde::__private::Formatter,
566 ) -> _serde::__private::fmt::Result {
567 _serde::__private::Formatter::write_str(
568 __formatter,
569 "enum EventRangeMode",
570 )
571 }
572 fn visit_enum<__A>(
573 self,
574 __data: __A,
575 ) -> _serde::__private::Result<Self::Value, __A::Error>
576 where
577 __A: _serde::de::EnumAccess<'de>,
578 {
579 match _serde::de::EnumAccess::variant(__data)? {
580 (__Field::__field0, __variant) => {
581 _serde::de::VariantAccess::unit_variant(__variant)?;
582 _serde::__private::Ok(
583 EventRangeMode::EVENT_MODE_SEND_ON_ENTER_RANGE,
584 )
585 }
586 (__Field::__field1, __variant) => {
587 _serde::de::VariantAccess::unit_variant(__variant)?;
588 _serde::__private::Ok(
589 EventRangeMode::EVENT_MODE_SEND_WHEN_IN_RANGE,
590 )
591 }
592 }
593 }
594 }
595 #[doc(hidden)]
596 const VARIANTS: &'static [&'static str] = &[
597 "EVENT_MODE_SEND_ON_ENTER_RANGE",
598 "EVENT_MODE_SEND_WHEN_IN_RANGE",
599 ];
600 _serde::Deserializer::deserialize_enum(
601 __deserializer,
602 "EventRangeMode",
603 VARIANTS,
604 __Visitor {
605 marker: _serde::__private::PhantomData::<EventRangeMode>,
606 lifetime: _serde::__private::PhantomData,
607 },
608 )
609 }
610 }
611};