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