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 hkbMirrorModifier<'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 = "isAdditive"))]
36 #[cfg_attr(feature = "serde", serde(rename = "isAdditive"))]
37 pub m_isAdditive: bool,
38}
39const _: () = {
40 use havok_serde as _serde;
41 impl<'a> _serde::HavokClass for hkbMirrorModifier<'a> {
42 #[inline]
43 fn name(&self) -> &'static str {
44 "hkbMirrorModifier"
45 }
46 #[inline]
47 fn signature(&self) -> _serde::__private::Signature {
48 _serde::__private::Signature::new(0xa9a271ea)
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
55 }
56 }
57 impl<'a> _serde::Serialize for hkbMirrorModifier<'a> {
58 fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
59 where
60 S: _serde::ser::Serializer,
61 {
62 let class_meta = self
63 .__ptr
64 .map(|name| (name, _serde::__private::Signature::new(0xa9a271ea)));
65 let mut serializer = __serializer
66 .serialize_struct("hkbMirrorModifier", class_meta, (48u64, 88u64))?;
67 serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
68 serializer
69 .skip_field(
70 "memSizeAndFlags",
71 &self.parent.parent.parent.parent.m_memSizeAndFlags,
72 )?;
73 serializer
74 .skip_field(
75 "referenceCount",
76 &self.parent.parent.parent.parent.m_referenceCount,
77 )?;
78 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
79 serializer
80 .serialize_field(
81 "variableBindingSet",
82 &self.parent.parent.parent.m_variableBindingSet,
83 )?;
84 serializer
85 .skip_array_field(
86 "cachedBindables",
87 &self.parent.parent.parent.m_cachedBindables,
88 TypeSize::NonPtr,
89 )?;
90 serializer
91 .skip_field(
92 "areBindablesCached",
93 &self.parent.parent.parent.m_areBindablesCached,
94 )?;
95 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
96 serializer.serialize_field("userData", &self.parent.parent.m_userData)?;
97 serializer.serialize_field("name", &self.parent.parent.m_name)?;
98 serializer.skip_field("id", &self.parent.parent.m_id)?;
99 serializer.skip_field("cloneState", &self.parent.parent.m_cloneState)?;
100 serializer
101 .skip_fixed_array_field(
102 "padNode",
103 self.parent.parent.m_padNode.as_slice(),
104 TypeSize::NonPtr,
105 )?;
106 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
107 serializer.serialize_field("enable", &self.parent.m_enable)?;
108 serializer
109 .skip_fixed_array_field(
110 "padModifier",
111 self.parent.m_padModifier.as_slice(),
112 TypeSize::NonPtr,
113 )?;
114 serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
115 serializer.serialize_field("isAdditive", &self.m_isAdditive)?;
116 serializer.pad_field([0u8; 3usize].as_slice(), [0u8; 7usize].as_slice())?;
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 hkbMirrorModifier<'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_isAdditive,
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 "isAdditive" => Ok(__Field::m_isAdditive),
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 __hkbMirrorModifierVisitor<'de> {
182 marker: _serde::__private::PhantomData<hkbMirrorModifier<'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 __hkbMirrorModifierVisitor<'de> {
189 type Value = hkbMirrorModifier<'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 hkbMirrorModifier",
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_isAdditive: _serde::__private::Option<bool> = _serde::__private::None;
209 for i in 0..1usize {
210 match i {
211 0usize => {
212 if _serde::__private::Option::is_some(&m_isAdditive) {
213 return _serde::__private::Err(
214 <__A::Error as _serde::de::Error>::duplicate_field(
215 "isAdditive",
216 ),
217 );
218 }
219 m_isAdditive = _serde::__private::Some(
220 match __A::next_value::<bool>(&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 __A::pad(&mut __map, 3usize, 7usize)?;
232 let m_isAdditive = match m_isAdditive {
233 _serde::__private::Some(__field) => __field,
234 _serde::__private::None => {
235 return _serde::__private::Err(
236 <__A::Error as _serde::de::Error>::missing_field(
237 "isAdditive",
238 ),
239 );
240 }
241 };
242 _serde::__private::Ok(hkbMirrorModifier {
243 __ptr,
244 parent,
245 m_isAdditive,
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_isAdditive: _serde::__private::Option<bool> = _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_isAdditive => {
368 #[cfg(
369 any(feature = "strict", feature = "ignore_duplicates")
370 )]
371 if _serde::__private::Option::is_some(&m_isAdditive) {
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(
380 "isAdditive",
381 ),
382 );
383 }
384 m_isAdditive = _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 _ => __A::skip_value(&mut __map)?,
394 }
395 }
396 let m_variableBindingSet = match m_variableBindingSet {
397 _serde::__private::Some(__field) => __field,
398 _serde::__private::None => {
399 #[cfg(feature = "strict")]
400 return _serde::__private::Err(
401 <__A::Error as _serde::de::Error>::missing_field(
402 "variableBindingSet",
403 ),
404 );
405 #[cfg(not(feature = "strict"))] Default::default()
406 }
407 };
408 let m_userData = match m_userData {
409 _serde::__private::Some(__field) => __field,
410 _serde::__private::None => {
411 #[cfg(feature = "strict")]
412 return _serde::__private::Err(
413 <__A::Error as _serde::de::Error>::missing_field("userData"),
414 );
415 #[cfg(not(feature = "strict"))] Default::default()
416 }
417 };
418 let m_name = match m_name {
419 _serde::__private::Some(__field) => __field,
420 _serde::__private::None => {
421 #[cfg(feature = "strict")]
422 return _serde::__private::Err(
423 <__A::Error as _serde::de::Error>::missing_field("name"),
424 );
425 #[cfg(not(feature = "strict"))] Default::default()
426 }
427 };
428 let m_enable = match m_enable {
429 _serde::__private::Some(__field) => __field,
430 _serde::__private::None => {
431 #[cfg(feature = "strict")]
432 return _serde::__private::Err(
433 <__A::Error as _serde::de::Error>::missing_field("enable"),
434 );
435 #[cfg(not(feature = "strict"))] Default::default()
436 }
437 };
438 let m_isAdditive = match m_isAdditive {
439 _serde::__private::Some(__field) => __field,
440 _serde::__private::None => {
441 #[cfg(feature = "strict")]
442 return _serde::__private::Err(
443 <__A::Error as _serde::de::Error>::missing_field(
444 "isAdditive",
445 ),
446 );
447 #[cfg(not(feature = "strict"))] Default::default()
448 }
449 };
450 let __ptr = None;
451 let parent = hkBaseObject { __ptr };
452 let parent = hkReferencedObject {
453 __ptr,
454 parent,
455 ..Default::default()
456 };
457 let parent = hkbBindable {
458 __ptr,
459 parent,
460 m_variableBindingSet,
461 ..Default::default()
462 };
463 let parent = hkbNode {
464 __ptr,
465 parent,
466 m_userData,
467 m_name,
468 ..Default::default()
469 };
470 let parent = hkbModifier {
471 __ptr,
472 parent,
473 m_enable,
474 ..Default::default()
475 };
476 let __ptr = __A::class_ptr(&mut __map);
477 _serde::__private::Ok(hkbMirrorModifier {
478 __ptr,
479 parent,
480 m_isAdditive,
481 })
482 }
483 }
484 const FIELDS: &[&str] = &["isAdditive"];
485 _serde::Deserializer::deserialize_struct(
486 deserializer,
487 "hkbMirrorModifier",
488 FIELDS,
489 __hkbMirrorModifierVisitor {
490 marker: _serde::__private::PhantomData::<hkbMirrorModifier>,
491 lifetime: _serde::__private::PhantomData,
492 },
493 )
494 }
495 }
496};