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