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 BSModifyOnceModifier<'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 = "pOnActivateModifier"))]
37 #[cfg_attr(feature = "serde", serde(rename = "pOnActivateModifier"))]
38 pub m_pOnActivateModifier: Pointer,
39 #[cfg_attr(feature = "json_schema", schemars(rename = "pOnDeactivateModifier"))]
45 #[cfg_attr(feature = "serde", serde(rename = "pOnDeactivateModifier"))]
46 pub m_pOnDeactivateModifier: Pointer,
47}
48const _: () = {
49 use havok_serde as _serde;
50 impl<'a> _serde::HavokClass for BSModifyOnceModifier<'a> {
51 #[inline]
52 fn name(&self) -> &'static str {
53 "BSModifyOnceModifier"
54 }
55 #[inline]
56 fn signature(&self) -> _serde::__private::Signature {
57 _serde::__private::Signature::new(0x1e20a97a)
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.push(self.parent.parent.parent.m_variableBindingSet.get());
63 v.push(self.m_pOnActivateModifier.get());
64 v.push(self.m_pOnDeactivateModifier.get());
65 v
66 }
67 }
68 impl<'a> _serde::Serialize for BSModifyOnceModifier<'a> {
69 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
70 where
71 S: _serde::ser::Serializer,
72 {
73 let class_meta = self
74 .__ptr
75 .map(|name| (name, _serde::__private::Signature::new(0x1e20a97a)));
76 let mut serializer = __serializer
77 .serialize_struct("BSModifyOnceModifier", class_meta, (80u64, 112u64))?;
78 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
79 serializer
80 .skip_field(
81 "memSizeAndFlags",
82 &self.parent.parent.parent.parent.m_memSizeAndFlags,
83 )?;
84 serializer
85 .skip_field(
86 "referenceCount",
87 &self.parent.parent.parent.parent.m_referenceCount,
88 )?;
89 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
90 serializer
91 .serialize_field(
92 "variableBindingSet",
93 &self.parent.parent.parent.m_variableBindingSet,
94 )?;
95 serializer
96 .skip_array_field(
97 "cachedBindables",
98 &self.parent.parent.parent.m_cachedBindables,
99 TypeSize::NonPtr,
100 )?;
101 serializer
102 .skip_field(
103 "areBindablesCached",
104 &self.parent.parent.parent.m_areBindablesCached,
105 )?;
106 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
107 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
108 serializer.serialize_field("name", &self.parent.parent.m_name)?;
109 serializer.skip_field("id", &self.parent.parent.m_id)?;
110 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
111 serializer
112 .skip_fixed_array_field(
113 "padNode",
114 self.parent.parent.m_padNode.as_slice(),
115 TypeSize::NonPtr,
116 )?;
117 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
118 serializer.serialize_field("enable", &self.parent.m_enable)?;
119 serializer
120 .skip_fixed_array_field(
121 "padModifier",
122 self.parent.m_padModifier.as_slice(),
123 TypeSize::NonPtr,
124 )?;
125 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
126 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 0usize].as_slice())?;
127 serializer
128 .serialize_field("pOnActivateModifier", &self.m_pOnActivateModifier)?;
129 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 8usize].as_slice())?;
130 serializer
131 .serialize_field(
132 "pOnDeactivateModifier",
133 &self.m_pOnDeactivateModifier,
134 )?;
135 serializer.pad_field([0u8; 12usize].as_slice(), [0u8; 8usize].as_slice())?;
136 serializer.end()
137 }
138 }
139};
140#[doc(hidden)]
141#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
142const _: () = {
143 use havok_serde as _serde;
144 #[automatically_derived]
145 impl<'de> _serde::Deserialize<'de> for BSModifyOnceModifier<'de> {
146 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
147 where
148 __D: _serde::Deserializer<'de>,
149 {
150 #[allow(non_camel_case_types)]
151 enum __Field {
152 m_variableBindingSet,
153 m_userData,
154 m_name,
155 m_enable,
156 m_pOnActivateModifier,
157 m_pOnDeactivateModifier,
158 __ignore,
159 }
160 struct __FieldVisitor;
161 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
162 type Value = __Field;
163 fn expecting(
164 &self,
165 __formatter: &mut core::fmt::Formatter,
166 ) -> core::fmt::Result {
167 core::fmt::Formatter::write_str(__formatter, "field identifier")
168 }
169 #[allow(clippy::match_single_binding)]
171 #[allow(clippy::reversed_empty_ranges)]
172 #[allow(clippy::single_match)]
173 fn visit_key<__E>(
174 self,
175 __value: &str,
176 ) -> core::result::Result<Self::Value, __E>
177 where
178 __E: _serde::de::Error,
179 {
180 match __value {
181 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
182 "userData" => Ok(__Field::m_userData),
183 "name" => Ok(__Field::m_name),
184 "enable" => Ok(__Field::m_enable),
185 "pOnActivateModifier" => Ok(__Field::m_pOnActivateModifier),
186 "pOnDeactivateModifier" => Ok(__Field::m_pOnDeactivateModifier),
187 _ => Ok(__Field::__ignore),
188 }
189 }
190 }
191 impl<'de> _serde::Deserialize<'de> for __Field {
192 #[inline]
193 fn deserialize<__D>(
194 __deserializer: __D,
195 ) -> core::result::Result<Self, __D::Error>
196 where
197 __D: _serde::Deserializer<'de>,
198 {
199 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
200 }
201 }
202 struct __BSModifyOnceModifierVisitor<'de> {
203 marker: _serde::__private::PhantomData<BSModifyOnceModifier<'de>>,
204 lifetime: _serde::__private::PhantomData<&'de ()>,
205 }
206 #[allow(clippy::match_single_binding)]
207 #[allow(clippy::reversed_empty_ranges)]
208 #[allow(clippy::single_match)]
209 impl<'de> _serde::de::Visitor<'de> for __BSModifyOnceModifierVisitor<'de> {
210 type Value = BSModifyOnceModifier<'de>;
211 fn expecting(
212 &self,
213 __formatter: &mut core::fmt::Formatter,
214 ) -> core::fmt::Result {
215 core::fmt::Formatter::write_str(
216 __formatter,
217 "struct BSModifyOnceModifier",
218 )
219 }
220 fn visit_struct_for_bytes<__A>(
221 self,
222 mut __map: __A,
223 ) -> _serde::__private::Result<Self::Value, __A::Error>
224 where
225 __A: _serde::de::MapAccess<'de>,
226 {
227 let __ptr = __A::class_ptr(&mut __map);
228 let parent = __A::parent_value(&mut __map)?;
229 let mut m_pOnActivateModifier: _serde::__private::Option<Pointer> = _serde::__private::None;
230 let mut m_pOnDeactivateModifier: _serde::__private::Option<
231 Pointer,
232 > = _serde::__private::None;
233 for i in 0..2usize {
234 match i {
235 0usize => {
236 if _serde::__private::Option::is_some(
237 &m_pOnActivateModifier,
238 ) {
239 return _serde::__private::Err(
240 <__A::Error as _serde::de::Error>::duplicate_field(
241 "pOnActivateModifier",
242 ),
243 );
244 }
245 __A::pad(&mut __map, 4usize, 0usize)?;
246 m_pOnActivateModifier = _serde::__private::Some(
247 match __A::next_value::<Pointer>(&mut __map) {
248 _serde::__private::Ok(__val) => __val,
249 _serde::__private::Err(__err) => {
250 return _serde::__private::Err(__err);
251 }
252 },
253 );
254 }
255 1usize => {
256 if _serde::__private::Option::is_some(
257 &m_pOnDeactivateModifier,
258 ) {
259 return _serde::__private::Err(
260 <__A::Error as _serde::de::Error>::duplicate_field(
261 "pOnDeactivateModifier",
262 ),
263 );
264 }
265 __A::pad(&mut __map, 12usize, 8usize)?;
266 m_pOnDeactivateModifier = _serde::__private::Some(
267 match __A::next_value::<Pointer>(&mut __map) {
268 _serde::__private::Ok(__val) => __val,
269 _serde::__private::Err(__err) => {
270 return _serde::__private::Err(__err);
271 }
272 },
273 );
274 }
275 _ => {}
276 }
277 }
278 __A::pad(&mut __map, 12usize, 8usize)?;
279 let m_pOnActivateModifier = match m_pOnActivateModifier {
280 _serde::__private::Some(__field) => __field,
281 _serde::__private::None => {
282 return _serde::__private::Err(
283 <__A::Error as _serde::de::Error>::missing_field(
284 "pOnActivateModifier",
285 ),
286 );
287 }
288 };
289 let m_pOnDeactivateModifier = match m_pOnDeactivateModifier {
290 _serde::__private::Some(__field) => __field,
291 _serde::__private::None => {
292 return _serde::__private::Err(
293 <__A::Error as _serde::de::Error>::missing_field(
294 "pOnDeactivateModifier",
295 ),
296 );
297 }
298 };
299 _serde::__private::Ok(BSModifyOnceModifier {
300 __ptr,
301 parent,
302 m_pOnActivateModifier,
303 m_pOnDeactivateModifier,
304 })
305 }
306 #[allow(clippy::manual_unwrap_or_default)]
307 fn visit_struct<__A>(
308 self,
309 mut __map: __A,
310 ) -> _serde::__private::Result<Self::Value, __A::Error>
311 where
312 __A: _serde::de::MapAccess<'de>,
313 {
314 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
315 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
316 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
317 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
318 let mut m_pOnActivateModifier: _serde::__private::Option<Pointer> = _serde::__private::None;
319 let mut m_pOnDeactivateModifier: _serde::__private::Option<
320 Pointer,
321 > = _serde::__private::None;
322 while let _serde::__private::Some(__key) = {
323 __A::next_key::<__Field>(&mut __map)?
324 } {
325 match __key {
326 __Field::m_variableBindingSet => {
327 #[cfg(
328 any(feature = "strict", feature = "ignore_duplicates")
329 )]
330 if _serde::__private::Option::is_some(
331 &m_variableBindingSet,
332 ) {
333 #[cfg(feature = "ignore_duplicates")]
334 {
335 __A::skip_value(&mut __map)?;
336 continue;
337 }
338 #[cfg(feature = "strict")]
339 return _serde::__private::Err(
340 <__A::Error as _serde::de::Error>::duplicate_field(
341 "variableBindingSet",
342 ),
343 );
344 }
345 m_variableBindingSet = _serde::__private::Some(
346 match __A::next_value::<Pointer>(&mut __map) {
347 _serde::__private::Ok(__val) => __val,
348 _serde::__private::Err(__err) => {
349 return _serde::__private::Err(__err);
350 }
351 },
352 );
353 }
354 __Field::m_userData => {
355 #[cfg(
356 any(feature = "strict", feature = "ignore_duplicates")
357 )]
358 if _serde::__private::Option::is_some(&m_userData) {
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 "userData",
368 ),
369 );
370 }
371 m_userData = _serde::__private::Some(
372 match __A::next_value::<Ulong>(&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_name => {
381 #[cfg(
382 any(feature = "strict", feature = "ignore_duplicates")
383 )]
384 if _serde::__private::Option::is_some(&m_name) {
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("name"),
393 );
394 }
395 m_name = _serde::__private::Some(
396 match __A::next_value::<StringPtr<'de>>(&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_enable => {
405 #[cfg(
406 any(feature = "strict", feature = "ignore_duplicates")
407 )]
408 if _serde::__private::Option::is_some(&m_enable) {
409 #[cfg(feature = "ignore_duplicates")]
410 {
411 __A::skip_value(&mut __map)?;
412 continue;
413 }
414 #[cfg(feature = "strict")]
415 return _serde::__private::Err(
416 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
417 );
418 }
419 m_enable = _serde::__private::Some(
420 match __A::next_value::<bool>(&mut __map) {
421 _serde::__private::Ok(__val) => __val,
422 _serde::__private::Err(__err) => {
423 return _serde::__private::Err(__err);
424 }
425 },
426 );
427 }
428 __Field::m_pOnActivateModifier => {
429 #[cfg(
430 any(feature = "strict", feature = "ignore_duplicates")
431 )]
432 if _serde::__private::Option::is_some(
433 &m_pOnActivateModifier,
434 ) {
435 #[cfg(feature = "ignore_duplicates")]
436 {
437 __A::skip_value(&mut __map)?;
438 continue;
439 }
440 #[cfg(feature = "strict")]
441 return _serde::__private::Err(
442 <__A::Error as _serde::de::Error>::duplicate_field(
443 "pOnActivateModifier",
444 ),
445 );
446 }
447 m_pOnActivateModifier = _serde::__private::Some(
448 match __A::next_value::<Pointer>(&mut __map) {
449 _serde::__private::Ok(__val) => __val,
450 _serde::__private::Err(__err) => {
451 return _serde::__private::Err(__err);
452 }
453 },
454 );
455 }
456 __Field::m_pOnDeactivateModifier => {
457 #[cfg(
458 any(feature = "strict", feature = "ignore_duplicates")
459 )]
460 if _serde::__private::Option::is_some(
461 &m_pOnDeactivateModifier,
462 ) {
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 "pOnDeactivateModifier",
472 ),
473 );
474 }
475 m_pOnDeactivateModifier = _serde::__private::Some(
476 match __A::next_value::<Pointer>(&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_variableBindingSet = match m_variableBindingSet {
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 "variableBindingSet",
494 ),
495 );
496 #[cfg(not(feature = "strict"))] Default::default()
497 }
498 };
499 let m_userData = match m_userData {
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("userData"),
505 );
506 #[cfg(not(feature = "strict"))] Default::default()
507 }
508 };
509 let m_name = match m_name {
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("name"),
515 );
516 #[cfg(not(feature = "strict"))] Default::default()
517 }
518 };
519 let m_enable = match m_enable {
520 _serde::__private::Some(__field) => __field,
521 _serde::__private::None => {
522 #[cfg(feature = "strict")]
523 return _serde::__private::Err(
524 <__A::Error as _serde::de::Error>::missing_field("enable"),
525 );
526 #[cfg(not(feature = "strict"))] Default::default()
527 }
528 };
529 let m_pOnActivateModifier = match m_pOnActivateModifier {
530 _serde::__private::Some(__field) => __field,
531 _serde::__private::None => {
532 #[cfg(feature = "strict")]
533 return _serde::__private::Err(
534 <__A::Error as _serde::de::Error>::missing_field(
535 "pOnActivateModifier",
536 ),
537 );
538 #[cfg(not(feature = "strict"))] Default::default()
539 }
540 };
541 let m_pOnDeactivateModifier = match m_pOnDeactivateModifier {
542 _serde::__private::Some(__field) => __field,
543 _serde::__private::None => {
544 #[cfg(feature = "strict")]
545 return _serde::__private::Err(
546 <__A::Error as _serde::de::Error>::missing_field(
547 "pOnDeactivateModifier",
548 ),
549 );
550 #[cfg(not(feature = "strict"))] Default::default()
551 }
552 };
553 let __ptr = None;
554 let parent = hkBaseObject { __ptr };
555 let parent = hkReferencedObject {
556 __ptr,
557 parent,
558 ..Default::default()
559 };
560 let parent = hkbBindable {
561 __ptr,
562 parent,
563 m_variableBindingSet,
564 ..Default::default()
565 };
566 let parent = hkbNode {
567 __ptr,
568 parent,
569 m_userData,
570 m_name,
571 ..Default::default()
572 };
573 let parent = hkbModifier {
574 __ptr,
575 parent,
576 m_enable,
577 ..Default::default()
578 };
579 let __ptr = __A::class_ptr(&mut __map);
580 _serde::__private::Ok(BSModifyOnceModifier {
581 __ptr,
582 parent,
583 m_pOnActivateModifier,
584 m_pOnDeactivateModifier,
585 })
586 }
587 }
588 const FIELDS: &[&str] = &["pOnActivateModifier", "pOnDeactivateModifier"];
589 _serde::Deserializer::deserialize_struct(
590 deserializer,
591 "BSModifyOnceModifier",
592 FIELDS,
593 __BSModifyOnceModifierVisitor {
594 marker: _serde::__private::PhantomData::<BSModifyOnceModifier>,
595 lifetime: _serde::__private::PhantomData,
596 },
597 )
598 }
599 }
600};