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