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 BGSGamebryoSequenceGenerator<'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: hkbGenerator<'a>,
31 #[cfg_attr(feature = "serde", serde(borrow))]
36 #[cfg_attr(feature = "json_schema", schemars(rename = "pSequence"))]
37 #[cfg_attr(feature = "serde", serde(rename = "pSequence"))]
38 pub m_pSequence: CString<'a>,
39 #[cfg_attr(feature = "json_schema", schemars(rename = "eBlendModeFunction"))]
44 #[cfg_attr(feature = "serde", serde(rename = "eBlendModeFunction"))]
45 pub m_eBlendModeFunction: BlendModeFunction,
46 #[cfg_attr(feature = "json_schema", schemars(rename = "fPercent"))]
51 #[cfg_attr(feature = "serde", serde(rename = "fPercent"))]
52 pub m_fPercent: f32,
53 #[cfg_attr(feature = "json_schema", schemars(rename = "events"))]
59 #[cfg_attr(feature = "serde", serde(rename = "events"))]
60 pub m_events: Vec<()>,
61 #[cfg_attr(feature = "json_schema", schemars(rename = "fTime"))]
67 #[cfg_attr(feature = "serde", serde(rename = "fTime"))]
68 pub m_fTime: f32,
69 #[cfg_attr(feature = "json_schema", schemars(rename = "bDelayedActivate"))]
75 #[cfg_attr(feature = "serde", serde(rename = "bDelayedActivate"))]
76 pub m_bDelayedActivate: bool,
77 #[cfg_attr(feature = "json_schema", schemars(rename = "bLooping"))]
83 #[cfg_attr(feature = "serde", serde(rename = "bLooping"))]
84 pub m_bLooping: bool,
85}
86const _: () = {
87 use havok_serde as _serde;
88 impl<'a> _serde::HavokClass for BGSGamebryoSequenceGenerator<'a> {
89 #[inline]
90 fn name(&self) -> &'static str {
91 "BGSGamebryoSequenceGenerator"
92 }
93 #[inline]
94 fn signature(&self) -> _serde::__private::Signature {
95 _serde::__private::Signature::new(0xc8df2d77)
96 }
97 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
98 fn deps_indexes(&self) -> Vec<usize> {
99 let mut v = Vec::new();
100 v.push(self.parent.parent.parent.m_variableBindingSet.get());
101 v
102 }
103 }
104 impl<'a> _serde::Serialize for BGSGamebryoSequenceGenerator<'a> {
105 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
106 where
107 S: _serde::ser::Serializer,
108 {
109 let class_meta = self
110 .__ptr
111 .map(|name| (name, _serde::__private::Signature::new(0xc8df2d77)));
112 let mut serializer = __serializer
113 .serialize_struct(
114 "BGSGamebryoSequenceGenerator",
115 class_meta,
116 (72u64, 112u64),
117 )?;
118 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
119 serializer
120 .skip_field(
121 "memSizeAndFlags",
122 &self.parent.parent.parent.parent.m_memSizeAndFlags,
123 )?;
124 serializer
125 .skip_field(
126 "referenceCount",
127 &self.parent.parent.parent.parent.m_referenceCount,
128 )?;
129 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
130 serializer
131 .serialize_field(
132 "variableBindingSet",
133 &self.parent.parent.parent.m_variableBindingSet,
134 )?;
135 serializer
136 .skip_array_field(
137 "cachedBindables",
138 &self.parent.parent.parent.m_cachedBindables,
139 TypeSize::NonPtr,
140 )?;
141 serializer
142 .skip_field(
143 "areBindablesCached",
144 &self.parent.parent.parent.m_areBindablesCached,
145 )?;
146 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
147 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
148 serializer.serialize_field("name", &self.parent.parent.m_name)?;
149 serializer.skip_field("id", &self.parent.parent.m_id)?;
150 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
151 serializer
152 .skip_fixed_array_field(
153 "padNode",
154 self.parent.parent.m_padNode.as_slice(),
155 TypeSize::NonPtr,
156 )?;
157 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
158 serializer.serialize_field("pSequence", &self.m_pSequence)?;
159 serializer
160 .serialize_field("eBlendModeFunction", &self.m_eBlendModeFunction)?;
161 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 3usize].as_slice())?;
162 serializer.serialize_field("fPercent", &self.m_fPercent)?;
163 serializer.skip_array_field("events", &self.m_events, TypeSize::NonPtr)?;
164 serializer.skip_field("fTime", &self.m_fTime)?;
165 serializer.skip_field("bDelayedActivate", &self.m_bDelayedActivate)?;
166 serializer.skip_field("bLooping", &self.m_bLooping)?;
167 serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
168 serializer.end()
169 }
170 }
171};
172#[doc(hidden)]
173#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
174const _: () = {
175 use havok_serde as _serde;
176 #[automatically_derived]
177 impl<'de> _serde::Deserialize<'de> for BGSGamebryoSequenceGenerator<'de> {
178 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
179 where
180 __D: _serde::Deserializer<'de>,
181 {
182 #[allow(non_camel_case_types)]
183 enum __Field {
184 m_variableBindingSet,
185 m_userData,
186 m_name,
187 m_pSequence,
188 m_eBlendModeFunction,
189 m_fPercent,
190 __ignore,
191 }
192 struct __FieldVisitor;
193 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
194 type Value = __Field;
195 fn expecting(
196 &self,
197 __formatter: &mut core::fmt::Formatter,
198 ) -> core::fmt::Result {
199 core::fmt::Formatter::write_str(__formatter, "field identifier")
200 }
201 #[allow(clippy::match_single_binding)]
203 #[allow(clippy::reversed_empty_ranges)]
204 #[allow(clippy::single_match)]
205 fn visit_key<__E>(
206 self,
207 __value: &str,
208 ) -> core::result::Result<Self::Value, __E>
209 where
210 __E: _serde::de::Error,
211 {
212 match __value {
213 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
214 "userData" => Ok(__Field::m_userData),
215 "name" => Ok(__Field::m_name),
216 "pSequence" => Ok(__Field::m_pSequence),
217 "eBlendModeFunction" => Ok(__Field::m_eBlendModeFunction),
218 "fPercent" => Ok(__Field::m_fPercent),
219 _ => Ok(__Field::__ignore),
220 }
221 }
222 }
223 impl<'de> _serde::Deserialize<'de> for __Field {
224 #[inline]
225 fn deserialize<__D>(
226 __deserializer: __D,
227 ) -> core::result::Result<Self, __D::Error>
228 where
229 __D: _serde::Deserializer<'de>,
230 {
231 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
232 }
233 }
234 struct __BGSGamebryoSequenceGeneratorVisitor<'de> {
235 marker: _serde::__private::PhantomData<
236 BGSGamebryoSequenceGenerator<'de>,
237 >,
238 lifetime: _serde::__private::PhantomData<&'de ()>,
239 }
240 #[allow(clippy::match_single_binding)]
241 #[allow(clippy::reversed_empty_ranges)]
242 #[allow(clippy::single_match)]
243 impl<'de> _serde::de::Visitor<'de>
244 for __BGSGamebryoSequenceGeneratorVisitor<'de> {
245 type Value = BGSGamebryoSequenceGenerator<'de>;
246 fn expecting(
247 &self,
248 __formatter: &mut core::fmt::Formatter,
249 ) -> core::fmt::Result {
250 core::fmt::Formatter::write_str(
251 __formatter,
252 "struct BGSGamebryoSequenceGenerator",
253 )
254 }
255 fn visit_struct_for_bytes<__A>(
256 self,
257 mut __map: __A,
258 ) -> _serde::__private::Result<Self::Value, __A::Error>
259 where
260 __A: _serde::de::MapAccess<'de>,
261 {
262 let __ptr = __A::class_ptr(&mut __map);
263 let parent = __A::parent_value(&mut __map)?;
264 let mut m_pSequence: _serde::__private::Option<CString<'de>> = _serde::__private::None;
265 let mut m_eBlendModeFunction: _serde::__private::Option<
266 BlendModeFunction,
267 > = _serde::__private::None;
268 let mut m_fPercent: _serde::__private::Option<f32> = _serde::__private::None;
269 let mut m_events: _serde::__private::Option<Vec<()>> = _serde::__private::None;
270 let mut m_fTime: _serde::__private::Option<f32> = _serde::__private::None;
271 let mut m_bDelayedActivate: _serde::__private::Option<bool> = _serde::__private::None;
272 let mut m_bLooping: _serde::__private::Option<bool> = _serde::__private::None;
273 for i in 0..7usize {
274 match i {
275 0usize => {
276 if _serde::__private::Option::is_some(&m_pSequence) {
277 return _serde::__private::Err(
278 <__A::Error as _serde::de::Error>::duplicate_field(
279 "pSequence",
280 ),
281 );
282 }
283 m_pSequence = _serde::__private::Some(
284 match __A::next_value::<CString<'de>>(&mut __map) {
285 _serde::__private::Ok(__val) => __val,
286 _serde::__private::Err(__err) => {
287 return _serde::__private::Err(__err);
288 }
289 },
290 );
291 }
292 1usize => {
293 if _serde::__private::Option::is_some(
294 &m_eBlendModeFunction,
295 ) {
296 return _serde::__private::Err(
297 <__A::Error as _serde::de::Error>::duplicate_field(
298 "eBlendModeFunction",
299 ),
300 );
301 }
302 m_eBlendModeFunction = _serde::__private::Some(
303 match __A::next_value::<BlendModeFunction>(&mut __map) {
304 _serde::__private::Ok(__val) => __val,
305 _serde::__private::Err(__err) => {
306 return _serde::__private::Err(__err);
307 }
308 },
309 );
310 }
311 2usize => {
312 if _serde::__private::Option::is_some(&m_fPercent) {
313 return _serde::__private::Err(
314 <__A::Error as _serde::de::Error>::duplicate_field(
315 "fPercent",
316 ),
317 );
318 }
319 __A::pad(&mut __map, 3usize, 3usize)?;
320 m_fPercent = _serde::__private::Some(
321 match __A::next_value::<f32>(&mut __map) {
322 _serde::__private::Ok(__val) => __val,
323 _serde::__private::Err(__err) => {
324 return _serde::__private::Err(__err);
325 }
326 },
327 );
328 }
329 3usize => {
330 if _serde::__private::Option::is_some(&m_events) {
331 return _serde::__private::Err(
332 <__A::Error as _serde::de::Error>::duplicate_field("events"),
333 );
334 }
335 m_events = _serde::__private::Some(
336 match __A::next_value::<Vec<()>>(&mut __map) {
337 _serde::__private::Ok(__val) => __val,
338 _serde::__private::Err(__err) => {
339 return _serde::__private::Err(__err);
340 }
341 },
342 );
343 }
344 4usize => {
345 if _serde::__private::Option::is_some(&m_fTime) {
346 return _serde::__private::Err(
347 <__A::Error as _serde::de::Error>::duplicate_field("fTime"),
348 );
349 }
350 m_fTime = _serde::__private::Some(
351 match __A::next_value::<f32>(&mut __map) {
352 _serde::__private::Ok(__val) => __val,
353 _serde::__private::Err(__err) => {
354 return _serde::__private::Err(__err);
355 }
356 },
357 );
358 }
359 5usize => {
360 if _serde::__private::Option::is_some(&m_bDelayedActivate) {
361 return _serde::__private::Err(
362 <__A::Error as _serde::de::Error>::duplicate_field(
363 "bDelayedActivate",
364 ),
365 );
366 }
367 m_bDelayedActivate = _serde::__private::Some(
368 match __A::next_value::<bool>(&mut __map) {
369 _serde::__private::Ok(__val) => __val,
370 _serde::__private::Err(__err) => {
371 return _serde::__private::Err(__err);
372 }
373 },
374 );
375 }
376 6usize => {
377 if _serde::__private::Option::is_some(&m_bLooping) {
378 return _serde::__private::Err(
379 <__A::Error as _serde::de::Error>::duplicate_field(
380 "bLooping",
381 ),
382 );
383 }
384 m_bLooping = _serde::__private::Some(
385 match __A::next_value::<bool>(&mut __map) {
386 _serde::__private::Ok(__val) => __val,
387 _serde::__private::Err(__err) => {
388 return _serde::__private::Err(__err);
389 }
390 },
391 );
392 }
393 _ => {}
394 }
395 }
396 __A::pad(&mut __map, 2usize, 2usize)?;
397 let m_pSequence = match m_pSequence {
398 _serde::__private::Some(__field) => __field,
399 _serde::__private::None => {
400 return _serde::__private::Err(
401 <__A::Error as _serde::de::Error>::missing_field(
402 "pSequence",
403 ),
404 );
405 }
406 };
407 let m_eBlendModeFunction = match m_eBlendModeFunction {
408 _serde::__private::Some(__field) => __field,
409 _serde::__private::None => {
410 return _serde::__private::Err(
411 <__A::Error as _serde::de::Error>::missing_field(
412 "eBlendModeFunction",
413 ),
414 );
415 }
416 };
417 let m_fPercent = match m_fPercent {
418 _serde::__private::Some(__field) => __field,
419 _serde::__private::None => {
420 return _serde::__private::Err(
421 <__A::Error as _serde::de::Error>::missing_field("fPercent"),
422 );
423 }
424 };
425 let m_events = match m_events {
426 _serde::__private::Some(__field) => __field,
427 _serde::__private::None => {
428 return _serde::__private::Err(
429 <__A::Error as _serde::de::Error>::missing_field("events"),
430 );
431 }
432 };
433 let m_fTime = match m_fTime {
434 _serde::__private::Some(__field) => __field,
435 _serde::__private::None => {
436 return _serde::__private::Err(
437 <__A::Error as _serde::de::Error>::missing_field("fTime"),
438 );
439 }
440 };
441 let m_bDelayedActivate = match m_bDelayedActivate {
442 _serde::__private::Some(__field) => __field,
443 _serde::__private::None => {
444 return _serde::__private::Err(
445 <__A::Error as _serde::de::Error>::missing_field(
446 "bDelayedActivate",
447 ),
448 );
449 }
450 };
451 let m_bLooping = match m_bLooping {
452 _serde::__private::Some(__field) => __field,
453 _serde::__private::None => {
454 return _serde::__private::Err(
455 <__A::Error as _serde::de::Error>::missing_field("bLooping"),
456 );
457 }
458 };
459 _serde::__private::Ok(BGSGamebryoSequenceGenerator {
460 __ptr,
461 parent,
462 m_pSequence,
463 m_eBlendModeFunction,
464 m_fPercent,
465 m_events,
466 m_fTime,
467 m_bDelayedActivate,
468 m_bLooping,
469 })
470 }
471 #[allow(clippy::manual_unwrap_or_default)]
472 fn visit_struct<__A>(
473 self,
474 mut __map: __A,
475 ) -> _serde::__private::Result<Self::Value, __A::Error>
476 where
477 __A: _serde::de::MapAccess<'de>,
478 {
479 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
480 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
481 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
482 let mut m_pSequence: _serde::__private::Option<CString<'de>> = _serde::__private::None;
483 let mut m_eBlendModeFunction: _serde::__private::Option<
484 BlendModeFunction,
485 > = _serde::__private::None;
486 let mut m_fPercent: _serde::__private::Option<f32> = _serde::__private::None;
487 while let _serde::__private::Some(__key) = {
488 __A::next_key::<__Field>(&mut __map)?
489 } {
490 match __key {
491 __Field::m_variableBindingSet => {
492 #[cfg(
493 any(feature = "strict", feature = "ignore_duplicates")
494 )]
495 if _serde::__private::Option::is_some(
496 &m_variableBindingSet,
497 ) {
498 #[cfg(feature = "ignore_duplicates")]
499 {
500 __A::skip_value(&mut __map)?;
501 continue;
502 }
503 #[cfg(feature = "strict")]
504 return _serde::__private::Err(
505 <__A::Error as _serde::de::Error>::duplicate_field(
506 "variableBindingSet",
507 ),
508 );
509 }
510 m_variableBindingSet = _serde::__private::Some(
511 match __A::next_value::<Pointer>(&mut __map) {
512 _serde::__private::Ok(__val) => __val,
513 _serde::__private::Err(__err) => {
514 return _serde::__private::Err(__err);
515 }
516 },
517 );
518 }
519 __Field::m_userData => {
520 #[cfg(
521 any(feature = "strict", feature = "ignore_duplicates")
522 )]
523 if _serde::__private::Option::is_some(&m_userData) {
524 #[cfg(feature = "ignore_duplicates")]
525 {
526 __A::skip_value(&mut __map)?;
527 continue;
528 }
529 #[cfg(feature = "strict")]
530 return _serde::__private::Err(
531 <__A::Error as _serde::de::Error>::duplicate_field(
532 "userData",
533 ),
534 );
535 }
536 m_userData = _serde::__private::Some(
537 match __A::next_value::<Ulong>(&mut __map) {
538 _serde::__private::Ok(__val) => __val,
539 _serde::__private::Err(__err) => {
540 return _serde::__private::Err(__err);
541 }
542 },
543 );
544 }
545 __Field::m_name => {
546 #[cfg(
547 any(feature = "strict", feature = "ignore_duplicates")
548 )]
549 if _serde::__private::Option::is_some(&m_name) {
550 #[cfg(feature = "ignore_duplicates")]
551 {
552 __A::skip_value(&mut __map)?;
553 continue;
554 }
555 #[cfg(feature = "strict")]
556 return _serde::__private::Err(
557 <__A::Error as _serde::de::Error>::duplicate_field("name"),
558 );
559 }
560 m_name = _serde::__private::Some(
561 match __A::next_value::<StringPtr<'de>>(&mut __map) {
562 _serde::__private::Ok(__val) => __val,
563 _serde::__private::Err(__err) => {
564 return _serde::__private::Err(__err);
565 }
566 },
567 );
568 }
569 __Field::m_pSequence => {
570 #[cfg(
571 any(feature = "strict", feature = "ignore_duplicates")
572 )]
573 if _serde::__private::Option::is_some(&m_pSequence) {
574 #[cfg(feature = "ignore_duplicates")]
575 {
576 __A::skip_value(&mut __map)?;
577 continue;
578 }
579 #[cfg(feature = "strict")]
580 return _serde::__private::Err(
581 <__A::Error as _serde::de::Error>::duplicate_field(
582 "pSequence",
583 ),
584 );
585 }
586 m_pSequence = _serde::__private::Some(
587 match __A::next_value::<CString<'de>>(&mut __map) {
588 _serde::__private::Ok(__val) => __val,
589 _serde::__private::Err(__err) => {
590 return _serde::__private::Err(__err);
591 }
592 },
593 );
594 }
595 __Field::m_eBlendModeFunction => {
596 #[cfg(
597 any(feature = "strict", feature = "ignore_duplicates")
598 )]
599 if _serde::__private::Option::is_some(
600 &m_eBlendModeFunction,
601 ) {
602 #[cfg(feature = "ignore_duplicates")]
603 {
604 __A::skip_value(&mut __map)?;
605 continue;
606 }
607 #[cfg(feature = "strict")]
608 return _serde::__private::Err(
609 <__A::Error as _serde::de::Error>::duplicate_field(
610 "eBlendModeFunction",
611 ),
612 );
613 }
614 m_eBlendModeFunction = _serde::__private::Some(
615 match __A::next_value::<BlendModeFunction>(&mut __map) {
616 _serde::__private::Ok(__val) => __val,
617 _serde::__private::Err(__err) => {
618 return _serde::__private::Err(__err);
619 }
620 },
621 );
622 }
623 __Field::m_fPercent => {
624 #[cfg(
625 any(feature = "strict", feature = "ignore_duplicates")
626 )]
627 if _serde::__private::Option::is_some(&m_fPercent) {
628 #[cfg(feature = "ignore_duplicates")]
629 {
630 __A::skip_value(&mut __map)?;
631 continue;
632 }
633 #[cfg(feature = "strict")]
634 return _serde::__private::Err(
635 <__A::Error as _serde::de::Error>::duplicate_field(
636 "fPercent",
637 ),
638 );
639 }
640 m_fPercent = _serde::__private::Some(
641 match __A::next_value::<f32>(&mut __map) {
642 _serde::__private::Ok(__val) => __val,
643 _serde::__private::Err(__err) => {
644 return _serde::__private::Err(__err);
645 }
646 },
647 );
648 }
649 _ => __A::skip_value(&mut __map)?,
650 }
651 }
652 let m_variableBindingSet = match m_variableBindingSet {
653 _serde::__private::Some(__field) => __field,
654 _serde::__private::None => {
655 #[cfg(feature = "strict")]
656 return _serde::__private::Err(
657 <__A::Error as _serde::de::Error>::missing_field(
658 "variableBindingSet",
659 ),
660 );
661 #[cfg(not(feature = "strict"))] Default::default()
662 }
663 };
664 let m_userData = match m_userData {
665 _serde::__private::Some(__field) => __field,
666 _serde::__private::None => {
667 #[cfg(feature = "strict")]
668 return _serde::__private::Err(
669 <__A::Error as _serde::de::Error>::missing_field("userData"),
670 );
671 #[cfg(not(feature = "strict"))] Default::default()
672 }
673 };
674 let m_name = match m_name {
675 _serde::__private::Some(__field) => __field,
676 _serde::__private::None => {
677 #[cfg(feature = "strict")]
678 return _serde::__private::Err(
679 <__A::Error as _serde::de::Error>::missing_field("name"),
680 );
681 #[cfg(not(feature = "strict"))] Default::default()
682 }
683 };
684 let m_pSequence = match m_pSequence {
685 _serde::__private::Some(__field) => __field,
686 _serde::__private::None => {
687 #[cfg(feature = "strict")]
688 return _serde::__private::Err(
689 <__A::Error as _serde::de::Error>::missing_field(
690 "pSequence",
691 ),
692 );
693 #[cfg(not(feature = "strict"))] Default::default()
694 }
695 };
696 let m_eBlendModeFunction = match m_eBlendModeFunction {
697 _serde::__private::Some(__field) => __field,
698 _serde::__private::None => {
699 #[cfg(feature = "strict")]
700 return _serde::__private::Err(
701 <__A::Error as _serde::de::Error>::missing_field(
702 "eBlendModeFunction",
703 ),
704 );
705 #[cfg(not(feature = "strict"))] Default::default()
706 }
707 };
708 let m_fPercent = match m_fPercent {
709 _serde::__private::Some(__field) => __field,
710 _serde::__private::None => {
711 #[cfg(feature = "strict")]
712 return _serde::__private::Err(
713 <__A::Error as _serde::de::Error>::missing_field("fPercent"),
714 );
715 #[cfg(not(feature = "strict"))] Default::default()
716 }
717 };
718 let __ptr = None;
719 let parent = hkBaseObject { __ptr };
720 let parent = hkReferencedObject {
721 __ptr,
722 parent,
723 ..Default::default()
724 };
725 let parent = hkbBindable {
726 __ptr,
727 parent,
728 m_variableBindingSet,
729 ..Default::default()
730 };
731 let parent = hkbNode {
732 __ptr,
733 parent,
734 m_userData,
735 m_name,
736 ..Default::default()
737 };
738 let parent = hkbGenerator { __ptr, parent };
739 let __ptr = __A::class_ptr(&mut __map);
740 _serde::__private::Ok(BGSGamebryoSequenceGenerator {
741 __ptr,
742 parent,
743 m_pSequence,
744 m_eBlendModeFunction,
745 m_fPercent,
746 ..Default::default()
747 })
748 }
749 }
750 const FIELDS: &[&str] = &[
751 "pSequence",
752 "eBlendModeFunction",
753 "fPercent",
754 "events",
755 "fTime",
756 "bDelayedActivate",
757 "bLooping",
758 ];
759 _serde::Deserializer::deserialize_struct(
760 deserializer,
761 "BGSGamebryoSequenceGenerator",
762 FIELDS,
763 __BGSGamebryoSequenceGeneratorVisitor {
764 marker: _serde::__private::PhantomData::<
765 BGSGamebryoSequenceGenerator,
766 >,
767 lifetime: _serde::__private::PhantomData,
768 },
769 )
770 }
771 }
772};
773#[allow(non_upper_case_globals, non_snake_case)]
776#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
777#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
778#[derive(
779 Debug,
780 Clone,
781 Default,
782 PartialEq,
783 Eq,
784 PartialOrd,
785 Ord,
786 num_derive::ToPrimitive,
787 num_derive::FromPrimitive,
788)]
789pub enum BlendModeFunction {
790 #[default]
791 BMF_NONE = 0isize,
792 BMF_PERCENT = 1isize,
793 BMF_ONE_MINUS_PERCENT = 2isize,
794}
795const _: () = {
796 use havok_serde as __serde;
797 impl __serde::Serialize for BlendModeFunction {
798 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
799 where
800 S: __serde::ser::Serializer,
801 {
802 let mut __serializer = __serializer.serialize_enum_flags()?;
803 match self {
804 Self::BMF_NONE => __serializer.serialize_field("BMF_NONE", &0u64),
805 Self::BMF_PERCENT => __serializer.serialize_field("BMF_PERCENT", &1u64),
806 Self::BMF_ONE_MINUS_PERCENT => {
807 __serializer.serialize_field("BMF_ONE_MINUS_PERCENT", &2u64)
808 }
809 }?;
810 use num_traits::ToPrimitive as _;
811 let num = self
812 .to_i8()
813 .ok_or(S::Error::custom("Failed enum BlendModeFunction to_i8"))?;
814 __serializer.serialize_bits(&num)?;
815 __serializer.end()
816 }
817 }
818};
819#[doc(hidden)]
820#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
821const _: () = {
822 #[allow(unused_extern_crates, clippy::useless_attribute)]
823 extern crate havok_serde as _serde;
824 #[automatically_derived]
825 impl<'de> _serde::Deserialize<'de> for BlendModeFunction {
826 fn deserialize<__D>(
827 __deserializer: __D,
828 ) -> _serde::__private::Result<Self, __D::Error>
829 where
830 __D: _serde::Deserializer<'de>,
831 {
832 #[allow(non_camel_case_types)]
833 #[doc(hidden)]
834 enum __Field {
835 __field0,
836 __field1,
837 __field2,
838 }
839 #[doc(hidden)]
840 struct __FieldVisitor;
841 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
842 type Value = __Field;
843 fn expecting(
844 &self,
845 __formatter: &mut _serde::__private::Formatter,
846 ) -> _serde::__private::fmt::Result {
847 _serde::__private::Formatter::write_str(
848 __formatter,
849 "variant identifier",
850 )
851 }
852 fn visit_int8<__E>(
853 self,
854 __value: i8,
855 ) -> _serde::__private::Result<Self::Value, __E>
856 where
857 __E: _serde::de::Error,
858 {
859 match __value {
860 0i8 => _serde::__private::Ok(__Field::__field0),
861 1i8 => _serde::__private::Ok(__Field::__field1),
862 2i8 => _serde::__private::Ok(__Field::__field2),
863 _ => {
864 _serde::__private::Err(
865 _serde::de::Error::invalid_value(
866 _serde::de::Unexpected::Int8(__value),
867 &"value(i8) of variant is one of 0, 1, 2",
868 ),
869 )
870 }
871 }
872 }
873 fn visit_stringptr<__E>(
874 self,
875 __value: StringPtr<'de>,
876 ) -> _serde::__private::Result<Self::Value, __E>
877 where
878 __E: _serde::de::Error,
879 {
880 if let Some(__value) = __value.into_inner() {
881 match __value.as_ref() {
882 v if v == "0" || v.eq_ignore_ascii_case("BMF_NONE") => {
883 _serde::__private::Ok(__Field::__field0)
884 }
885 v if v == "1" || v.eq_ignore_ascii_case("BMF_PERCENT") => {
886 _serde::__private::Ok(__Field::__field1)
887 }
888 v if v == "2"
889 || v.eq_ignore_ascii_case("BMF_ONE_MINUS_PERCENT") => {
890 _serde::__private::Ok(__Field::__field2)
891 }
892 _ => {
893 _serde::__private::Err(
894 _serde::de::Error::unknown_variant(&__value, VARIANTS),
895 )
896 }
897 }
898 } else {
899 _serde::__private::Err(
900 _serde::de::Error::unknown_variant("None", VARIANTS),
901 )
902 }
903 }
904 }
905 impl<'de> _serde::Deserialize<'de> for __Field {
906 #[inline]
907 fn deserialize<__D>(
908 __deserializer: __D,
909 ) -> _serde::__private::Result<Self, __D::Error>
910 where
911 __D: _serde::Deserializer<'de>,
912 {
913 _serde::Deserializer::deserialize_identifier(
914 __deserializer,
915 _serde::de::ReadEnumSize::Int8,
916 __FieldVisitor,
917 )
918 }
919 }
920 #[doc(hidden)]
921 struct __Visitor<'de> {
922 marker: _serde::__private::PhantomData<BlendModeFunction>,
923 lifetime: _serde::__private::PhantomData<&'de ()>,
924 }
925 impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
926 type Value = BlendModeFunction;
927 fn expecting(
928 &self,
929 __formatter: &mut _serde::__private::Formatter,
930 ) -> _serde::__private::fmt::Result {
931 _serde::__private::Formatter::write_str(
932 __formatter,
933 "enum BlendModeFunction",
934 )
935 }
936 fn visit_enum<__A>(
937 self,
938 __data: __A,
939 ) -> _serde::__private::Result<Self::Value, __A::Error>
940 where
941 __A: _serde::de::EnumAccess<'de>,
942 {
943 match _serde::de::EnumAccess::variant(__data)? {
944 (__Field::__field0, __variant) => {
945 _serde::de::VariantAccess::unit_variant(__variant)?;
946 _serde::__private::Ok(BlendModeFunction::BMF_NONE)
947 }
948 (__Field::__field1, __variant) => {
949 _serde::de::VariantAccess::unit_variant(__variant)?;
950 _serde::__private::Ok(BlendModeFunction::BMF_PERCENT)
951 }
952 (__Field::__field2, __variant) => {
953 _serde::de::VariantAccess::unit_variant(__variant)?;
954 _serde::__private::Ok(
955 BlendModeFunction::BMF_ONE_MINUS_PERCENT,
956 )
957 }
958 }
959 }
960 }
961 #[doc(hidden)]
962 const VARIANTS: &'static [&'static str] = &[
963 "BMF_NONE",
964 "BMF_PERCENT",
965 "BMF_ONE_MINUS_PERCENT",
966 ];
967 _serde::Deserializer::deserialize_enum(
968 __deserializer,
969 "BlendModeFunction",
970 VARIANTS,
971 __Visitor {
972 marker: _serde::__private::PhantomData::<BlendModeFunction>,
973 lifetime: _serde::__private::PhantomData,
974 },
975 )
976 }
977 }
978};