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