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 hkbModifierList<'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 = "modifiers"))]
36 #[cfg_attr(feature = "serde", serde(rename = "modifiers"))]
37 pub m_modifiers: Vec<Pointer>,
38}
39const _: () = {
40 use havok_serde as _serde;
41 impl<'a> _serde::HavokClass for hkbModifierList<'a> {
42 #[inline]
43 fn name(&self) -> &'static str {
44 "hkbModifierList"
45 }
46 #[inline]
47 fn signature(&self) -> _serde::__private::Signature {
48 _serde::__private::Signature::new(0xa4180ca1)
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_modifiers.iter().map(|ptr| ptr.get()));
55 v
56 }
57 }
58 impl<'a> _serde::Serialize for hkbModifierList<'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(0xa4180ca1)));
66 let mut serializer = __serializer
67 .serialize_struct("hkbModifierList", class_meta, (56u64, 96u64))?;
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
117 .serialize_array_field(
118 "modifiers",
119 &self.m_modifiers,
120 TypeSize::NonPtr,
121 )?;
122 serializer.end()
123 }
124 }
125};
126#[doc(hidden)]
127#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
128const _: () = {
129 use havok_serde as _serde;
130 #[automatically_derived]
131 impl<'de> _serde::Deserialize<'de> for hkbModifierList<'de> {
132 fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
133 where
134 __D: _serde::Deserializer<'de>,
135 {
136 #[allow(non_camel_case_types)]
137 enum __Field {
138 m_variableBindingSet,
139 m_userData,
140 m_name,
141 m_enable,
142 m_modifiers,
143 __ignore,
144 }
145 struct __FieldVisitor;
146 impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
147 type Value = __Field;
148 fn expecting(
149 &self,
150 __formatter: &mut core::fmt::Formatter,
151 ) -> core::fmt::Result {
152 core::fmt::Formatter::write_str(__formatter, "field identifier")
153 }
154 #[allow(clippy::match_single_binding)]
156 #[allow(clippy::reversed_empty_ranges)]
157 #[allow(clippy::single_match)]
158 fn visit_key<__E>(
159 self,
160 __value: &str,
161 ) -> core::result::Result<Self::Value, __E>
162 where
163 __E: _serde::de::Error,
164 {
165 match __value {
166 "variableBindingSet" => Ok(__Field::m_variableBindingSet),
167 "userData" => Ok(__Field::m_userData),
168 "name" => Ok(__Field::m_name),
169 "enable" => Ok(__Field::m_enable),
170 "modifiers" => Ok(__Field::m_modifiers),
171 _ => Ok(__Field::__ignore),
172 }
173 }
174 }
175 impl<'de> _serde::Deserialize<'de> for __Field {
176 #[inline]
177 fn deserialize<__D>(
178 __deserializer: __D,
179 ) -> core::result::Result<Self, __D::Error>
180 where
181 __D: _serde::Deserializer<'de>,
182 {
183 _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
184 }
185 }
186 struct __hkbModifierListVisitor<'de> {
187 marker: _serde::__private::PhantomData<hkbModifierList<'de>>,
188 lifetime: _serde::__private::PhantomData<&'de ()>,
189 }
190 #[allow(clippy::match_single_binding)]
191 #[allow(clippy::reversed_empty_ranges)]
192 #[allow(clippy::single_match)]
193 impl<'de> _serde::de::Visitor<'de> for __hkbModifierListVisitor<'de> {
194 type Value = hkbModifierList<'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 hkbModifierList",
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_modifiers: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
214 for i in 0..1usize {
215 match i {
216 0usize => {
217 if _serde::__private::Option::is_some(&m_modifiers) {
218 return _serde::__private::Err(
219 <__A::Error as _serde::de::Error>::duplicate_field(
220 "modifiers",
221 ),
222 );
223 }
224 m_modifiers = _serde::__private::Some(
225 match __A::next_value::<Vec<Pointer>>(&mut __map) {
226 _serde::__private::Ok(__val) => __val,
227 _serde::__private::Err(__err) => {
228 return _serde::__private::Err(__err);
229 }
230 },
231 );
232 }
233 _ => {}
234 }
235 }
236 let m_modifiers = match m_modifiers {
237 _serde::__private::Some(__field) => __field,
238 _serde::__private::None => {
239 return _serde::__private::Err(
240 <__A::Error as _serde::de::Error>::missing_field(
241 "modifiers",
242 ),
243 );
244 }
245 };
246 _serde::__private::Ok(hkbModifierList {
247 __ptr,
248 parent,
249 m_modifiers,
250 })
251 }
252 #[allow(clippy::manual_unwrap_or_default)]
253 fn visit_struct<__A>(
254 self,
255 mut __map: __A,
256 ) -> _serde::__private::Result<Self::Value, __A::Error>
257 where
258 __A: _serde::de::MapAccess<'de>,
259 {
260 let mut m_variableBindingSet: _serde::__private::Option<Pointer> = _serde::__private::None;
261 let mut m_userData: _serde::__private::Option<Ulong> = _serde::__private::None;
262 let mut m_name: _serde::__private::Option<StringPtr<'de>> = _serde::__private::None;
263 let mut m_enable: _serde::__private::Option<bool> = _serde::__private::None;
264 let mut m_modifiers: _serde::__private::Option<Vec<Pointer>> = _serde::__private::None;
265 while let _serde::__private::Some(__key) = {
266 __A::next_key::<__Field>(&mut __map)?
267 } {
268 match __key {
269 __Field::m_variableBindingSet => {
270 #[cfg(
271 any(feature = "strict", feature = "ignore_duplicates")
272 )]
273 if _serde::__private::Option::is_some(
274 &m_variableBindingSet,
275 ) {
276 #[cfg(feature = "ignore_duplicates")]
277 {
278 __A::skip_value(&mut __map)?;
279 continue;
280 }
281 #[cfg(feature = "strict")]
282 return _serde::__private::Err(
283 <__A::Error as _serde::de::Error>::duplicate_field(
284 "variableBindingSet",
285 ),
286 );
287 }
288 m_variableBindingSet = _serde::__private::Some(
289 match __A::next_value::<Pointer>(&mut __map) {
290 _serde::__private::Ok(__val) => __val,
291 _serde::__private::Err(__err) => {
292 return _serde::__private::Err(__err);
293 }
294 },
295 );
296 }
297 __Field::m_userData => {
298 #[cfg(
299 any(feature = "strict", feature = "ignore_duplicates")
300 )]
301 if _serde::__private::Option::is_some(&m_userData) {
302 #[cfg(feature = "ignore_duplicates")]
303 {
304 __A::skip_value(&mut __map)?;
305 continue;
306 }
307 #[cfg(feature = "strict")]
308 return _serde::__private::Err(
309 <__A::Error as _serde::de::Error>::duplicate_field(
310 "userData",
311 ),
312 );
313 }
314 m_userData = _serde::__private::Some(
315 match __A::next_value::<Ulong>(&mut __map) {
316 _serde::__private::Ok(__val) => __val,
317 _serde::__private::Err(__err) => {
318 return _serde::__private::Err(__err);
319 }
320 },
321 );
322 }
323 __Field::m_name => {
324 #[cfg(
325 any(feature = "strict", feature = "ignore_duplicates")
326 )]
327 if _serde::__private::Option::is_some(&m_name) {
328 #[cfg(feature = "ignore_duplicates")]
329 {
330 __A::skip_value(&mut __map)?;
331 continue;
332 }
333 #[cfg(feature = "strict")]
334 return _serde::__private::Err(
335 <__A::Error as _serde::de::Error>::duplicate_field("name"),
336 );
337 }
338 m_name = _serde::__private::Some(
339 match __A::next_value::<StringPtr<'de>>(&mut __map) {
340 _serde::__private::Ok(__val) => __val,
341 _serde::__private::Err(__err) => {
342 return _serde::__private::Err(__err);
343 }
344 },
345 );
346 }
347 __Field::m_enable => {
348 #[cfg(
349 any(feature = "strict", feature = "ignore_duplicates")
350 )]
351 if _serde::__private::Option::is_some(&m_enable) {
352 #[cfg(feature = "ignore_duplicates")]
353 {
354 __A::skip_value(&mut __map)?;
355 continue;
356 }
357 #[cfg(feature = "strict")]
358 return _serde::__private::Err(
359 <__A::Error as _serde::de::Error>::duplicate_field("enable"),
360 );
361 }
362 m_enable = _serde::__private::Some(
363 match __A::next_value::<bool>(&mut __map) {
364 _serde::__private::Ok(__val) => __val,
365 _serde::__private::Err(__err) => {
366 return _serde::__private::Err(__err);
367 }
368 },
369 );
370 }
371 __Field::m_modifiers => {
372 #[cfg(
373 any(feature = "strict", feature = "ignore_duplicates")
374 )]
375 if _serde::__private::Option::is_some(&m_modifiers) {
376 #[cfg(feature = "ignore_duplicates")]
377 {
378 __A::skip_value(&mut __map)?;
379 continue;
380 }
381 #[cfg(feature = "strict")]
382 return _serde::__private::Err(
383 <__A::Error as _serde::de::Error>::duplicate_field(
384 "modifiers",
385 ),
386 );
387 }
388 m_modifiers = _serde::__private::Some(
389 match __A::next_value::<Vec<Pointer>>(&mut __map) {
390 _serde::__private::Ok(__val) => __val,
391 _serde::__private::Err(__err) => {
392 return _serde::__private::Err(__err);
393 }
394 },
395 );
396 }
397 _ => __A::skip_value(&mut __map)?,
398 }
399 }
400 let m_variableBindingSet = match m_variableBindingSet {
401 _serde::__private::Some(__field) => __field,
402 _serde::__private::None => {
403 #[cfg(feature = "strict")]
404 return _serde::__private::Err(
405 <__A::Error as _serde::de::Error>::missing_field(
406 "variableBindingSet",
407 ),
408 );
409 #[cfg(not(feature = "strict"))] Default::default()
410 }
411 };
412 let m_userData = match m_userData {
413 _serde::__private::Some(__field) => __field,
414 _serde::__private::None => {
415 #[cfg(feature = "strict")]
416 return _serde::__private::Err(
417 <__A::Error as _serde::de::Error>::missing_field("userData"),
418 );
419 #[cfg(not(feature = "strict"))] Default::default()
420 }
421 };
422 let m_name = match m_name {
423 _serde::__private::Some(__field) => __field,
424 _serde::__private::None => {
425 #[cfg(feature = "strict")]
426 return _serde::__private::Err(
427 <__A::Error as _serde::de::Error>::missing_field("name"),
428 );
429 #[cfg(not(feature = "strict"))] Default::default()
430 }
431 };
432 let m_enable = match m_enable {
433 _serde::__private::Some(__field) => __field,
434 _serde::__private::None => {
435 #[cfg(feature = "strict")]
436 return _serde::__private::Err(
437 <__A::Error as _serde::de::Error>::missing_field("enable"),
438 );
439 #[cfg(not(feature = "strict"))] Default::default()
440 }
441 };
442 let m_modifiers = match m_modifiers {
443 _serde::__private::Some(__field) => __field,
444 _serde::__private::None => {
445 #[cfg(feature = "strict")]
446 return _serde::__private::Err(
447 <__A::Error as _serde::de::Error>::missing_field(
448 "modifiers",
449 ),
450 );
451 #[cfg(not(feature = "strict"))] Default::default()
452 }
453 };
454 let __ptr = None;
455 let parent = hkBaseObject { __ptr };
456 let parent = hkReferencedObject {
457 __ptr,
458 parent,
459 ..Default::default()
460 };
461 let parent = hkbBindable {
462 __ptr,
463 parent,
464 m_variableBindingSet,
465 ..Default::default()
466 };
467 let parent = hkbNode {
468 __ptr,
469 parent,
470 m_userData,
471 m_name,
472 ..Default::default()
473 };
474 let parent = hkbModifier {
475 __ptr,
476 parent,
477 m_enable,
478 ..Default::default()
479 };
480 let __ptr = __A::class_ptr(&mut __map);
481 _serde::__private::Ok(hkbModifierList {
482 __ptr,
483 parent,
484 m_modifiers,
485 })
486 }
487 }
488 const FIELDS: &[&str] = &["modifiers"];
489 _serde::Deserializer::deserialize_struct(
490 deserializer,
491 "hkbModifierList",
492 FIELDS,
493 __hkbModifierListVisitor {
494 marker: _serde::__private::PhantomData::<hkbModifierList>,
495 lifetime: _serde::__private::PhantomData,
496 },
497 )
498 }
499 }
500};