havok_classes/generated/
hkpAgent1nSector_.rs

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

havok_classes/generated/
hkpAgent1nSector_.rs
