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