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