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 hkbEvaluateExpressionModifier<'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 = "expressions"))]
36 #[cfg_attr(feature = "serde", serde(rename = "expressions"))]
37 pub m_expressions: Pointer,
38 #[cfg_attr(feature = "json_schema", schemars(rename = "compiledExpressionSet"))]
44 #[cfg_attr(feature = "serde", serde(rename = "compiledExpressionSet"))]
45 pub m_compiledExpressionSet: Pointer,
46 #[cfg_attr(feature = "json_schema", schemars(rename = "internalExpressionsData"))]
52 #[cfg_attr(feature = "serde", serde(rename = "internalExpressionsData"))]
53 pub m_internalExpressionsData: Vec<()>,
54}
55const _: () = {
56 use havok_serde as _serde;
57 impl<'a> _serde::HavokClass for hkbEvaluateExpressionModifier<'a> {
58 #[inline]
59 fn name(&self) -> &'static str {
60 "hkbEvaluateExpressionModifier"
61 }
62 #[inline]
63 fn signature(&self) -> _serde::__private::Signature {
64 _serde::__private::Signature::new(0xf900f6be)
65 }
66 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
67 fn deps_indexes(&self) -> Vec<usize> {
68 let mut v = Vec::new();
69 v.push(self.parent.parent.parent.m_variableBindingSet.get());
70 v.push(self.m_expressions.get());
71 v.push(self.m_compiledExpressionSet.get());
72 v
73 }
74 }
75 impl<'a> _serde::Serialize for hkbEvaluateExpressionModifier<'a> {
76 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
77 where
78 S: _serde::ser::Serializer,
79 {
80 let class_meta = self
81 .__ptr
82 .map(|name| (name, _serde::__private::Signature::new(0xf900f6be)));
83 let mut serializer = __serializer
84 .serialize_struct(
85 "hkbEvaluateExpressionModifier",
86 class_meta,
87 (64u64, 112u64),
88 )?;
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.serialize_field("expressions", &self.m_expressions)?;
138 serializer
139 .skip_field("compiledExpressionSet", &self.m_compiledExpressionSet)?;
140 serializer
141 .skip_array_field(
142 "internalExpressionsData",
143 &self.m_internalExpressionsData,
144 TypeSize::NonPtr,
145 )?;
146 serializer.end()
147 }
148 }
149};
150#[doc(hidden)]
151#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
152const _: () = {
153 use havok_serde as _serde;
154 #[automatically_derived]
155 impl<'de> _serde::Deserialize<'de> for hkbEvaluateExpressionModifier<'de> {
156 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
157 where
158 __D: _serde::Deserializer<'de>,
159 {
160 #[allow(non_camel_case_types)]
161 enum __Field {
162 m_variableBindingSet,
163 m_userData,
164 m_name,
165 m_enable,
166 m_expressions,
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 "expressions" => Ok(__Field::m_expressions),
195 _ => Ok(__Field::__ignore),
196 }
197 }
198 }
199 impl<'de> _serde::Deserialize<'de> for __Field {
200 #[inline]
201 fn deserialize<__D>(
202 __deserializer: __D,
203 ) -> core::result::Result<Self, __D::Error>
204 where
205 __D: _serde::Deserializer<'de>,
206 {
207 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
208 }
209 }
210 struct __hkbEvaluateExpressionModifierVisitor<'de> {
211 marker: _serde::__private::PhantomData<
212 hkbEvaluateExpressionModifier<'de>,
213 >,
214 lifetime: _serde::__private::PhantomData<&'de ()>,
215 }
216 #[allow(clippy::match_single_binding)]
217 #[allow(clippy::reversed_empty_ranges)]
218 #[allow(clippy::single_match)]
219 impl<'de> _serde::de::Visitor<'de>
220 for __hkbEvaluateExpressionModifierVisitor<'de> {
221 type Value = hkbEvaluateExpressionModifier<'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 hkbEvaluateExpressionModifier",
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_expressions: _serde::__private::Option<Pointer> = _serde::__private::None;
241 let mut m_compiledExpressionSet: _serde::__private::Option<
242 Pointer,
243 > = _serde::__private::None;
244 let mut m_internalExpressionsData: _serde::__private::Option<
245 Vec<()>,
246 > = _serde::__private::None;
247 for i in 0..3usize {
248 match i {
249 0usize => {
250 if _serde::__private::Option::is_some(&m_expressions) {
251 return _serde::__private::Err(
252 <__A::Error as _serde::de::Error>::duplicate_field(
253 "expressions",
254 ),
255 );
256 }
257 m_expressions = _serde::__private::Some(
258 match __A::next_value::<Pointer>(&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(
268 &m_compiledExpressionSet,
269 ) {
270 return _serde::__private::Err(
271 <__A::Error as _serde::de::Error>::duplicate_field(
272 "compiledExpressionSet",
273 ),
274 );
275 }
276 m_compiledExpressionSet = _serde::__private::Some(
277 match __A::next_value::<Pointer>(&mut __map) {
278 _serde::__private::Ok(__val) => __val,
279 _serde::__private::Err(__err) => {
280 return _serde::__private::Err(__err);
281 }
282 },
283 );
284 }
285 2usize => {
286 if _serde::__private::Option::is_some(
287 &m_internalExpressionsData,
288 ) {
289 return _serde::__private::Err(
290 <__A::Error as _serde::de::Error>::duplicate_field(
291 "internalExpressionsData",
292 ),
293 );
294 }
295 m_internalExpressionsData = _serde::__private::Some(
296 match __A::next_value::<Vec<()>>(&mut __map) {
297 _serde::__private::Ok(__val) => __val,
298 _serde::__private::Err(__err) => {
299 return _serde::__private::Err(__err);
300 }
301 },
302 );
303 }
304 _ => {}
305 }
306 }
307 let m_expressions = match m_expressions {
308 _serde::__private::Some(__field) => __field,
309 _serde::__private::None => {
310 return _serde::__private::Err(
311 <__A::Error as _serde::de::Error>::missing_field(
312 "expressions",
313 ),
314 );
315 }
316 };
317 let m_compiledExpressionSet = match m_compiledExpressionSet {
318 _serde::__private::Some(__field) => __field,
319 _serde::__private::None => {
320 return _serde::__private::Err(
321 <__A::Error as _serde::de::Error>::missing_field(
322 "compiledExpressionSet",
323 ),
324 );
325 }
326 };
327 let m_internalExpressionsData = match m_internalExpressionsData {
328 _serde::__private::Some(__field) => __field,
329 _serde::__private::None => {
330 return _serde::__private::Err(
331 <__A::Error as _serde::de::Error>::missing_field(
332 "internalExpressionsData",
333 ),
334 );
335 }
336 };
337 _serde::__private::Ok(hkbEvaluateExpressionModifier {
338 __ptr,
339 parent,
340 m_expressions,
341 m_compiledExpressionSet,
342 m_internalExpressionsData,
343 })
344 }
345 #[allow(clippy::manual_unwrap_or_default)]
346 fn visit_struct<__A>(
347 self,
348 mut __map: __A,
349 ) -> _serde::__private::Result<Self::Value, __A::Error>
350 where
351 __A: _serde::de::MapAccess<'de>,
352 {
353 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
354 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
355 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
356 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
357 let mut m_expressions: _serde::__private::Option<Pointer> = _serde::__private::None;
358 while let _serde::__private::Some(__key) = {
359 __A::next_key::<__Field>(&mut __map)?
360 } {
361 match __key {
362 __Field::m_variableBindingSet => {
363 #[cfg(
364 any(feature = "strict", feature = "ignore_duplicates")
365 )]
366 if _serde::__private::Option::is_some(
367 &m_variableBindingSet,
368 ) {
369 #[cfg(feature = "ignore_duplicates")]
370 {
371 __A::skip_value(&mut __map)?;
372 continue;
373 }
374 #[cfg(feature = "strict")]
375 return _serde::__private::Err(
376 <__A::Error as _serde::de::Error>::duplicate_field(
377 "variableBindingSet",
378 ),
379 );
380 }
381 m_variableBindingSet = _serde::__private::Some(
382 match __A::next_value::<Pointer>(&mut __map) {
383 _serde::__private::Ok(__val) => __val,
384 _serde::__private::Err(__err) => {
385 return _serde::__private::Err(__err);
386 }
387 },
388 );
389 }
390 __Field::m_userData => {
391 #[cfg(
392 any(feature = "strict", feature = "ignore_duplicates")
393 )]
394 if _serde::__private::Option::is_some(&m_userData) {
395 #[cfg(feature = "ignore_duplicates")]
396 {
397 __A::skip_value(&mut __map)?;
398 continue;
399 }
400 #[cfg(feature = "strict")]
401 return _serde::__private::Err(
402 <__A::Error as _serde::de::Error>::duplicate_field(
403 "userData",
404 ),
405 );
406 }
407 m_userData = _serde::__private::Some(
408 match __A::next_value::<Ulong>(&mut __map) {
409 _serde::__private::Ok(__val) => __val,
410 _serde::__private::Err(__err) => {
411 return _serde::__private::Err(__err);
412 }
413 },
414 );
415 }
416 __Field::m_name => {
417 #[cfg(
418 any(feature = "strict", feature = "ignore_duplicates")
419 )]
420 if _serde::__private::Option::is_some(&m_name) {
421 #[cfg(feature = "ignore_duplicates")]
422 {
423 __A::skip_value(&mut __map)?;
424 continue;
425 }
426 #[cfg(feature = "strict")]
427 return _serde::__private::Err(
428 <__A::Error as _serde::de::Error>::duplicate_field("name"),
429 );
430 }
431 m_name = _serde::__private::Some(
432 match __A::next_value::<StringPtr<'de>>(&mut __map) {
433 _serde::__private::Ok(__val) => __val,
434 _serde::__private::Err(__err) => {
435 return _serde::__private::Err(__err);
436 }
437 },
438 );
439 }
440 __Field::m_enable => {
441 #[cfg(
442 any(feature = "strict", feature = "ignore_duplicates")
443 )]
444 if _serde::__private::Option::is_some(&m_enable) {
445 #[cfg(feature = "ignore_duplicates")]
446 {
447 __A::skip_value(&mut __map)?;
448 continue;
449 }
450 #[cfg(feature = "strict")]
451 return _serde::__private::Err(
452 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
453 );
454 }
455 m_enable = _serde::__private::Some(
456 match __A::next_value::<bool>(&mut __map) {
457 _serde::__private::Ok(__val) => __val,
458 _serde::__private::Err(__err) => {
459 return _serde::__private::Err(__err);
460 }
461 },
462 );
463 }
464 __Field::m_expressions => {
465 #[cfg(
466 any(feature = "strict", feature = "ignore_duplicates")
467 )]
468 if _serde::__private::Option::is_some(&m_expressions) {
469 #[cfg(feature = "ignore_duplicates")]
470 {
471 __A::skip_value(&mut __map)?;
472 continue;
473 }
474 #[cfg(feature = "strict")]
475 return _serde::__private::Err(
476 <__A::Error as _serde::de::Error>::duplicate_field(
477 "expressions",
478 ),
479 );
480 }
481 m_expressions = _serde::__private::Some(
482 match __A::next_value::<Pointer>(&mut __map) {
483 _serde::__private::Ok(__val) => __val,
484 _serde::__private::Err(__err) => {
485 return _serde::__private::Err(__err);
486 }
487 },
488 );
489 }
490 _ => __A::skip_value(&mut __map)?,
491 }
492 }
493 let m_variableBindingSet = match m_variableBindingSet {
494 _serde::__private::Some(__field) => __field,
495 _serde::__private::None => {
496 #[cfg(feature = "strict")]
497 return _serde::__private::Err(
498 <__A::Error as _serde::de::Error>::missing_field(
499 "variableBindingSet",
500 ),
501 );
502 #[cfg(not(feature = "strict"))] Default::default()
503 }
504 };
505 let m_userData = match m_userData {
506 _serde::__private::Some(__field) => __field,
507 _serde::__private::None => {
508 #[cfg(feature = "strict")]
509 return _serde::__private::Err(
510 <__A::Error as _serde::de::Error>::missing_field("userData"),
511 );
512 #[cfg(not(feature = "strict"))] Default::default()
513 }
514 };
515 let m_name = match m_name {
516 _serde::__private::Some(__field) => __field,
517 _serde::__private::None => {
518 #[cfg(feature = "strict")]
519 return _serde::__private::Err(
520 <__A::Error as _serde::de::Error>::missing_field("name"),
521 );
522 #[cfg(not(feature = "strict"))] Default::default()
523 }
524 };
525 let m_enable = match m_enable {
526 _serde::__private::Some(__field) => __field,
527 _serde::__private::None => {
528 #[cfg(feature = "strict")]
529 return _serde::__private::Err(
530 <__A::Error as _serde::de::Error>::missing_field("enable"),
531 );
532 #[cfg(not(feature = "strict"))] Default::default()
533 }
534 };
535 let m_expressions = match m_expressions {
536 _serde::__private::Some(__field) => __field,
537 _serde::__private::None => {
538 #[cfg(feature = "strict")]
539 return _serde::__private::Err(
540 <__A::Error as _serde::de::Error>::missing_field(
541 "expressions",
542 ),
543 );
544 #[cfg(not(feature = "strict"))] Default::default()
545 }
546 };
547 let __ptr = None;
548 let parent = hkBaseObject { __ptr };
549 let parent = hkReferencedObject {
550 __ptr,
551 parent,
552 ..Default::default()
553 };
554 let parent = hkbBindable {
555 __ptr,
556 parent,
557 m_variableBindingSet,
558 ..Default::default()
559 };
560 let parent = hkbNode {
561 __ptr,
562 parent,
563 m_userData,
564 m_name,
565 ..Default::default()
566 };
567 let parent = hkbModifier {
568 __ptr,
569 parent,
570 m_enable,
571 ..Default::default()
572 };
573 let __ptr = __A::class_ptr(&mut __map);
574 _serde::__private::Ok(hkbEvaluateExpressionModifier {
575 __ptr,
576 parent,
577 m_expressions,
578 ..Default::default()
579 })
580 }
581 }
582 const FIELDS: &[&str] = &[
583 "expressions",
584 "compiledExpressionSet",
585 "internalExpressionsData",
586 ];
587 _serde::Deserializer::deserialize_struct(
588 deserializer,
589 "hkbEvaluateExpressionModifier",
590 FIELDS,
591 __hkbEvaluateExpressionModifierVisitor {
592 marker: _serde::__private::PhantomData::<
593 hkbEvaluateExpressionModifier,
594 >,
595 lifetime: _serde::__private::PhantomData,
596 },
597 )
598 }
599 }
600};