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