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 BSEventOnDeactivateModifier<'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 = "event"))]
36 #[cfg_attr(feature = "serde", serde(rename = "event"))]
37 pub m_event: hkbEventProperty,
38}
39const _: () = {
40 use havok_serde as _serde;
41 impl<'a> _serde::HavokClass for BSEventOnDeactivateModifier<'a> {
42 #[inline]
43 fn name(&self) -> &'static str {
44 "BSEventOnDeactivateModifier"
45 }
46 #[inline]
47 fn signature(&self) -> _serde::__private::Signature {
48 _serde::__private::Signature::new(0x1062d993)
49 }
50 #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
51 fn deps_indexes(&self) -> Vec<usize> {
52 let mut v = Vec::new();
53 v.push(self.parent.parent.parent.m_variableBindingSet.get());
54 v.extend(self.m_event.deps_indexes());
55 v
56 }
57 }
58 impl<'a> _serde::Serialize for BSEventOnDeactivateModifier<'a> {
59 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
60 where
61 S: _serde::ser::Serializer,
62 {
63 let class_meta = self
64 .__ptr
65 .map(|name| (name, _serde::__private::Signature::new(0x1062d993)));
66 let mut serializer = __serializer
67 .serialize_struct(
68 "BSEventOnDeactivateModifier",
69 class_meta,
70 (52u64, 96u64),
71 )?;
72 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
73 serializer
74 .skip_field(
75 "memSizeAndFlags",
76 &self.parent.parent.parent.parent.m_memSizeAndFlags,
77 )?;
78 serializer
79 .skip_field(
80 "referenceCount",
81 &self.parent.parent.parent.parent.m_referenceCount,
82 )?;
83 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
84 serializer
85 .serialize_field(
86 "variableBindingSet",
87 &self.parent.parent.parent.m_variableBindingSet,
88 )?;
89 serializer
90 .skip_array_field(
91 "cachedBindables",
92 &self.parent.parent.parent.m_cachedBindables,
93 TypeSize::NonPtr,
94 )?;
95 serializer
96 .skip_field(
97 "areBindablesCached",
98 &self.parent.parent.parent.m_areBindablesCached,
99 )?;
100 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
101 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
102 serializer.serialize_field("name", &self.parent.parent.m_name)?;
103 serializer.skip_field("id", &self.parent.parent.m_id)?;
104 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
105 serializer
106 .skip_fixed_array_field(
107 "padNode",
108 self.parent.parent.m_padNode.as_slice(),
109 TypeSize::NonPtr,
110 )?;
111 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
112 serializer.serialize_field("enable", &self.parent.m_enable)?;
113 serializer
114 .skip_fixed_array_field(
115 "padModifier",
116 self.parent.m_padModifier.as_slice(),
117 TypeSize::NonPtr,
118 )?;
119 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
120 serializer.serialize_field("event", &self.m_event)?;
121 serializer.end()
122 }
123 }
124};
125#[doc(hidden)]
126#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
127const _: () = {
128 use havok_serde as _serde;
129 #[automatically_derived]
130 impl<'de> _serde::Deserialize<'de> for BSEventOnDeactivateModifier<'de> {
131 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
132 where
133 __D: _serde::Deserializer<'de>,
134 {
135 #[allow(non_camel_case_types)]
136 enum __Field {
137 m_variableBindingSet,
138 m_userData,
139 m_name,
140 m_enable,
141 m_event,
142 __ignore,
143 }
144 struct __FieldVisitor;
145 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
146 type Value = __Field;
147 fn expecting(
148 &self,
149 __formatter: &mut core::fmt::Formatter,
150 ) -> core::fmt::Result {
151 core::fmt::Formatter::write_str(__formatter, "field identifier")
152 }
153 #[allow(clippy::match_single_binding)]
155 #[allow(clippy::reversed_empty_ranges)]
156 #[allow(clippy::single_match)]
157 fn visit_key<__E>(
158 self,
159 __value: &str,
160 ) -> core::result::Result<Self::Value, __E>
161 where
162 __E: _serde::de::Error,
163 {
164 match __value {
165 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
166 "userData" => Ok(__Field::m_userData),
167 "name" => Ok(__Field::m_name),
168 "enable" => Ok(__Field::m_enable),
169 "event" => Ok(__Field::m_event),
170 _ => Ok(__Field::__ignore),
171 }
172 }
173 }
174 impl<'de> _serde::Deserialize<'de> for __Field {
175 #[inline]
176 fn deserialize<__D>(
177 __deserializer: __D,
178 ) -> core::result::Result<Self, __D::Error>
179 where
180 __D: _serde::Deserializer<'de>,
181 {
182 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
183 }
184 }
185 struct __BSEventOnDeactivateModifierVisitor<'de> {
186 marker: _serde::__private::PhantomData<BSEventOnDeactivateModifier<'de>>,
187 lifetime: _serde::__private::PhantomData<&'de ()>,
188 }
189 #[allow(clippy::match_single_binding)]
190 #[allow(clippy::reversed_empty_ranges)]
191 #[allow(clippy::single_match)]
192 impl<'de> _serde::de::Visitor<'de>
193 for __BSEventOnDeactivateModifierVisitor<'de> {
194 type Value = BSEventOnDeactivateModifier<'de>;
195 fn expecting(
196 &self,
197 __formatter: &mut core::fmt::Formatter,
198 ) -> core::fmt::Result {
199 core::fmt::Formatter::write_str(
200 __formatter,
201 "struct BSEventOnDeactivateModifier",
202 )
203 }
204 fn visit_struct_for_bytes<__A>(
205 self,
206 mut __map: __A,
207 ) -> _serde::__private::Result<Self::Value, __A::Error>
208 where
209 __A: _serde::de::MapAccess<'de>,
210 {
211 let __ptr = __A::class_ptr(&mut __map);
212 let parent = __A::parent_value(&mut __map)?;
213 let mut m_event: _serde::__private::Option<hkbEventProperty> = _serde::__private::None;
214 for i in 0..1usize {
215 match i {
216 0usize => {
217 if _serde::__private::Option::is_some(&m_event) {
218 return _serde::__private::Err(
219 <__A::Error as _serde::de::Error>::duplicate_field("event"),
220 );
221 }
222 m_event = _serde::__private::Some(
223 match __A::next_value::<hkbEventProperty>(&mut __map) {
224 _serde::__private::Ok(__val) => __val,
225 _serde::__private::Err(__err) => {
226 return _serde::__private::Err(__err);
227 }
228 },
229 );
230 }
231 _ => {}
232 }
233 }
234 let m_event = match m_event {
235 _serde::__private::Some(__field) => __field,
236 _serde::__private::None => {
237 return _serde::__private::Err(
238 <__A::Error as _serde::de::Error>::missing_field("event"),
239 );
240 }
241 };
242 _serde::__private::Ok(BSEventOnDeactivateModifier {
243 __ptr,
244 parent,
245 m_event,
246 })
247 }
248 #[allow(clippy::manual_unwrap_or_default)]
249 fn visit_struct<__A>(
250 self,
251 mut __map: __A,
252 ) -> _serde::__private::Result<Self::Value, __A::Error>
253 where
254 __A: _serde::de::MapAccess<'de>,
255 {
256 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
257 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
258 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
259 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
260 let mut m_event: _serde::__private::Option<hkbEventProperty> = _serde::__private::None;
261 while let _serde::__private::Some(__key) = {
262 __A::next_key::<__Field>(&mut __map)?
263 } {
264 match __key {
265 __Field::m_variableBindingSet => {
266 #[cfg(
267 any(feature = "strict", feature = "ignore_duplicates")
268 )]
269 if _serde::__private::Option::is_some(
270 &m_variableBindingSet,
271 ) {
272 #[cfg(feature = "ignore_duplicates")]
273 {
274 __A::skip_value(&mut __map)?;
275 continue;
276 }
277 #[cfg(feature = "strict")]
278 return _serde::__private::Err(
279 <__A::Error as _serde::de::Error>::duplicate_field(
280 "variableBindingSet",
281 ),
282 );
283 }
284 m_variableBindingSet = _serde::__private::Some(
285 match __A::next_value::<Pointer>(&mut __map) {
286 _serde::__private::Ok(__val) => __val,
287 _serde::__private::Err(__err) => {
288 return _serde::__private::Err(__err);
289 }
290 },
291 );
292 }
293 __Field::m_userData => {
294 #[cfg(
295 any(feature = "strict", feature = "ignore_duplicates")
296 )]
297 if _serde::__private::Option::is_some(&m_userData) {
298 #[cfg(feature = "ignore_duplicates")]
299 {
300 __A::skip_value(&mut __map)?;
301 continue;
302 }
303 #[cfg(feature = "strict")]
304 return _serde::__private::Err(
305 <__A::Error as _serde::de::Error>::duplicate_field(
306 "userData",
307 ),
308 );
309 }
310 m_userData = _serde::__private::Some(
311 match __A::next_value::<Ulong>(&mut __map) {
312 _serde::__private::Ok(__val) => __val,
313 _serde::__private::Err(__err) => {
314 return _serde::__private::Err(__err);
315 }
316 },
317 );
318 }
319 __Field::m_name => {
320 #[cfg(
321 any(feature = "strict", feature = "ignore_duplicates")
322 )]
323 if _serde::__private::Option::is_some(&m_name) {
324 #[cfg(feature = "ignore_duplicates")]
325 {
326 __A::skip_value(&mut __map)?;
327 continue;
328 }
329 #[cfg(feature = "strict")]
330 return _serde::__private::Err(
331 <__A::Error as _serde::de::Error>::duplicate_field("name"),
332 );
333 }
334 m_name = _serde::__private::Some(
335 match __A::next_value::<StringPtr<'de>>(&mut __map) {
336 _serde::__private::Ok(__val) => __val,
337 _serde::__private::Err(__err) => {
338 return _serde::__private::Err(__err);
339 }
340 },
341 );
342 }
343 __Field::m_enable => {
344 #[cfg(
345 any(feature = "strict", feature = "ignore_duplicates")
346 )]
347 if _serde::__private::Option::is_some(&m_enable) {
348 #[cfg(feature = "ignore_duplicates")]
349 {
350 __A::skip_value(&mut __map)?;
351 continue;
352 }
353 #[cfg(feature = "strict")]
354 return _serde::__private::Err(
355 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
356 );
357 }
358 m_enable = _serde::__private::Some(
359 match __A::next_value::<bool>(&mut __map) {
360 _serde::__private::Ok(__val) => __val,
361 _serde::__private::Err(__err) => {
362 return _serde::__private::Err(__err);
363 }
364 },
365 );
366 }
367 __Field::m_event => {
368 #[cfg(
369 any(feature = "strict", feature = "ignore_duplicates")
370 )]
371 if _serde::__private::Option::is_some(&m_event) {
372 #[cfg(feature = "ignore_duplicates")]
373 {
374 __A::skip_value(&mut __map)?;
375 continue;
376 }
377 #[cfg(feature = "strict")]
378 return _serde::__private::Err(
379 <__A::Error as _serde::de::Error>::duplicate_field("event"),
380 );
381 }
382 m_event = _serde::__private::Some(
383 match __A::next_value::<hkbEventProperty>(&mut __map) {
384 _serde::__private::Ok(__val) => __val,
385 _serde::__private::Err(__err) => {
386 return _serde::__private::Err(__err);
387 }
388 },
389 );
390 }
391 _ => __A::skip_value(&mut __map)?,
392 }
393 }
394 let m_variableBindingSet = match m_variableBindingSet {
395 _serde::__private::Some(__field) => __field,
396 _serde::__private::None => {
397 #[cfg(feature = "strict")]
398 return _serde::__private::Err(
399 <__A::Error as _serde::de::Error>::missing_field(
400 "variableBindingSet",
401 ),
402 );
403 #[cfg(not(feature = "strict"))] Default::default()
404 }
405 };
406 let m_userData = match m_userData {
407 _serde::__private::Some(__field) => __field,
408 _serde::__private::None => {
409 #[cfg(feature = "strict")]
410 return _serde::__private::Err(
411 <__A::Error as _serde::de::Error>::missing_field("userData"),
412 );
413 #[cfg(not(feature = "strict"))] Default::default()
414 }
415 };
416 let m_name = match m_name {
417 _serde::__private::Some(__field) => __field,
418 _serde::__private::None => {
419 #[cfg(feature = "strict")]
420 return _serde::__private::Err(
421 <__A::Error as _serde::de::Error>::missing_field("name"),
422 );
423 #[cfg(not(feature = "strict"))] Default::default()
424 }
425 };
426 let m_enable = match m_enable {
427 _serde::__private::Some(__field) => __field,
428 _serde::__private::None => {
429 #[cfg(feature = "strict")]
430 return _serde::__private::Err(
431 <__A::Error as _serde::de::Error>::missing_field("enable"),
432 );
433 #[cfg(not(feature = "strict"))] Default::default()
434 }
435 };
436 let m_event = match m_event {
437 _serde::__private::Some(__field) => __field,
438 _serde::__private::None => {
439 #[cfg(feature = "strict")]
440 return _serde::__private::Err(
441 <__A::Error as _serde::de::Error>::missing_field("event"),
442 );
443 #[cfg(not(feature = "strict"))] Default::default()
444 }
445 };
446 let __ptr = None;
447 let parent = hkBaseObject { __ptr };
448 let parent = hkReferencedObject {
449 __ptr,
450 parent,
451 ..Default::default()
452 };
453 let parent = hkbBindable {
454 __ptr,
455 parent,
456 m_variableBindingSet,
457 ..Default::default()
458 };
459 let parent = hkbNode {
460 __ptr,
461 parent,
462 m_userData,
463 m_name,
464 ..Default::default()
465 };
466 let parent = hkbModifier {
467 __ptr,
468 parent,
469 m_enable,
470 ..Default::default()
471 };
472 let __ptr = __A::class_ptr(&mut __map);
473 _serde::__private::Ok(BSEventOnDeactivateModifier {
474 __ptr,
475 parent,
476 m_event,
477 })
478 }
479 }
480 const FIELDS: &[&str] = &["event"];
481 _serde::Deserializer::deserialize_struct(
482 deserializer,
483 "BSEventOnDeactivateModifier",
484 FIELDS,
485 __BSEventOnDeactivateModifierVisitor {
486 marker: _serde::__private::PhantomData::<
487 BSEventOnDeactivateModifier,
488 >,
489 lifetime: _serde::__private::PhantomData,
490 },
491 )
492 }
493 }
494};