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