havok_classes/generated/
hkxLight_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkxLight`
5/// - version: `1`
6/// - signature: `0x81c86d42`
7/// - size: ` 64`(x86)/` 80`(x86_64)
8/// -  vtable: `true`
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 hkxLight {
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    /// Alternative to C++ class inheritance.
27    #[cfg_attr(feature = "json_schema", schemars(flatten))]
28    #[cfg_attr(feature = "serde", serde(flatten))]
29    pub parent: hkReferencedObject,
30    /// # C++ Info
31    /// - name: `type`(ctype: `enum LightType`)
32    /// - offset: `  8`(x86)/` 16`(x86_64)
33    /// - type_size: `  1`(x86)/`  1`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "type"))]
35    #[cfg_attr(feature = "serde", serde(rename = "type"))]
36    pub m_type: LightType,
37    /// # C++ Info
38    /// - name: `position`(ctype: `hkVector4`)
39    /// - offset: ` 16`(x86)/` 32`(x86_64)
40    /// - type_size: ` 16`(x86)/` 16`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "position"))]
42    #[cfg_attr(feature = "serde", serde(rename = "position"))]
43    pub m_position: Vector4,
44    /// # C++ Info
45    /// - name: `direction`(ctype: `hkVector4`)
46    /// - offset: ` 32`(x86)/` 48`(x86_64)
47    /// - type_size: ` 16`(x86)/` 16`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "direction"))]
49    #[cfg_attr(feature = "serde", serde(rename = "direction"))]
50    pub m_direction: Vector4,
51    /// # C++ Info
52    /// - name: `color`(ctype: `hkUint32`)
53    /// - offset: ` 48`(x86)/` 64`(x86_64)
54    /// - type_size: `  4`(x86)/`  4`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "color"))]
56    #[cfg_attr(feature = "serde", serde(rename = "color"))]
57    pub m_color: u32,
58    /// # C++ Info
59    /// - name: `angle`(ctype: `hkReal`)
60    /// - offset: ` 52`(x86)/` 68`(x86_64)
61    /// - type_size: `  4`(x86)/`  4`(x86_64)
62    #[cfg_attr(feature = "json_schema", schemars(rename = "angle"))]
63    #[cfg_attr(feature = "serde", serde(rename = "angle"))]
64    pub m_angle: f32,
65}
66const _: () = {
67    use havok_serde as _serde;
68    impl _serde::HavokClass for hkxLight {
69        #[inline]
70        fn name(&self) -> &'static str {
71            "hkxLight"
72        }
73        #[inline]
74        fn signature(&self) -> _serde::__private::Signature {
75            _serde::__private::Signature::new(0x81c86d42)
76        }
77        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
78        fn deps_indexes(&self) -> Vec<usize> {
79            let mut v = Vec::new();
80            v
81        }
82    }
83    impl _serde::Serialize for hkxLight {
84        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
85        where
86            S: _serde::ser::Serializer,
87        {
88            let class_meta = self
89                .__ptr
90                .map(|name| (name, _serde::__private::Signature::new(0x81c86d42)));
91            let mut serializer = __serializer
92                .serialize_struct("hkxLight", class_meta, (64u64, 80u64))?;
93            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
94            serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
95            serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
96            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
97            serializer.serialize_field("type", &self.m_type)?;
98            serializer.pad_field([0u8; 7usize].as_slice(), [0u8; 15usize].as_slice())?;
99            serializer.serialize_field("position", &self.m_position)?;
100            serializer.serialize_field("direction", &self.m_direction)?;
101            serializer.serialize_field("color", &self.m_color)?;
102            serializer.serialize_field("angle", &self.m_angle)?;
103            serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 8usize].as_slice())?;
104            serializer.end()
105        }
106    }
107};
108#[doc(hidden)]
109#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
110const _: () = {
111    use havok_serde as _serde;
112    #[automatically_derived]
113    impl<'de> _serde::Deserialize<'de> for hkxLight {
114        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
115        where
116            __D: _serde::Deserializer<'de>,
117        {
118            #[allow(non_camel_case_types)]
119            enum __Field {
120                m_type,
121                m_position,
122                m_direction,
123                m_color,
124                m_angle,
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                /// Intended for use in XML.
137                #[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                        "type" => Ok(__Field::m_type),
149                        "position" => Ok(__Field::m_position),
150                        "direction" => Ok(__Field::m_direction),
151                        "color" => Ok(__Field::m_color),
152                        "angle" => Ok(__Field::m_angle),
153                        _ => Ok(__Field::__ignore),
154                    }
155                }
156            }
157            impl<'de> _serde::Deserialize<'de> for __Field {
158                #[inline]
159                fn deserialize<__D>(
160                    __deserializer: __D,
161                ) -> core::result::Result<Self, __D::Error>
162                where
163                    __D: _serde::Deserializer<'de>,
164                {
165                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
166                }
167            }
168            struct __hkxLightVisitor<'de> {
169                marker: _serde::__private::PhantomData<hkxLight>,
170                lifetime: _serde::__private::PhantomData<&'de ()>,
171            }
172            #[allow(clippy::match_single_binding)]
173            #[allow(clippy::reversed_empty_ranges)]
174            #[allow(clippy::single_match)]
175            impl<'de> _serde::de::Visitor<'de> for __hkxLightVisitor<'de> {
176                type Value = hkxLight;
177                fn expecting(
178                    &self,
179                    __formatter: &mut core::fmt::Formatter,
180                ) -> core::fmt::Result {
181                    core::fmt::Formatter::write_str(__formatter, "struct hkxLight")
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_type: _serde::__private::Option<LightType> = _serde::__private::None;
193                    let mut m_position: _serde::__private::Option<Vector4> = _serde::__private::None;
194                    let mut m_direction: _serde::__private::Option<Vector4> = _serde::__private::None;
195                    let mut m_color: _serde::__private::Option<u32> = _serde::__private::None;
196                    let mut m_angle: _serde::__private::Option<f32> = _serde::__private::None;
197                    for i in 0..5usize {
198                        match i {
199                            0usize => {
200                                if _serde::__private::Option::is_some(&m_type) {
201                                    return _serde::__private::Err(
202                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
203                                    );
204                                }
205                                m_type = _serde::__private::Some(
206                                    match __A::next_value::<LightType>(&mut __map) {
207                                        _serde::__private::Ok(__val) => __val,
208                                        _serde::__private::Err(__err) => {
209                                            return _serde::__private::Err(__err);
210                                        }
211                                    },
212                                );
213                            }
214                            1usize => {
215                                if _serde::__private::Option::is_some(&m_position) {
216                                    return _serde::__private::Err(
217                                        <__A::Error as _serde::de::Error>::duplicate_field(
218                                            "position",
219                                        ),
220                                    );
221                                }
222                                __A::pad(&mut __map, 7usize, 15usize)?;
223                                m_position = _serde::__private::Some(
224                                    match __A::next_value::<Vector4>(&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(&m_direction) {
234                                    return _serde::__private::Err(
235                                        <__A::Error as _serde::de::Error>::duplicate_field(
236                                            "direction",
237                                        ),
238                                    );
239                                }
240                                m_direction = _serde::__private::Some(
241                                    match __A::next_value::<Vector4>(&mut __map) {
242                                        _serde::__private::Ok(__val) => __val,
243                                        _serde::__private::Err(__err) => {
244                                            return _serde::__private::Err(__err);
245                                        }
246                                    },
247                                );
248                            }
249                            3usize => {
250                                if _serde::__private::Option::is_some(&m_color) {
251                                    return _serde::__private::Err(
252                                        <__A::Error as _serde::de::Error>::duplicate_field("color"),
253                                    );
254                                }
255                                m_color = _serde::__private::Some(
256                                    match __A::next_value::<u32>(&mut __map) {
257                                        _serde::__private::Ok(__val) => __val,
258                                        _serde::__private::Err(__err) => {
259                                            return _serde::__private::Err(__err);
260                                        }
261                                    },
262                                );
263                            }
264                            4usize => {
265                                if _serde::__private::Option::is_some(&m_angle) {
266                                    return _serde::__private::Err(
267                                        <__A::Error as _serde::de::Error>::duplicate_field("angle"),
268                                    );
269                                }
270                                m_angle = _serde::__private::Some(
271                                    match __A::next_value::<f32>(&mut __map) {
272                                        _serde::__private::Ok(__val) => __val,
273                                        _serde::__private::Err(__err) => {
274                                            return _serde::__private::Err(__err);
275                                        }
276                                    },
277                                );
278                            }
279                            _ => {}
280                        }
281                    }
282                    __A::pad(&mut __map, 8usize, 8usize)?;
283                    let m_type = match m_type {
284                        _serde::__private::Some(__field) => __field,
285                        _serde::__private::None => {
286                            return _serde::__private::Err(
287                                <__A::Error as _serde::de::Error>::missing_field("type"),
288                            );
289                        }
290                    };
291                    let m_position = match m_position {
292                        _serde::__private::Some(__field) => __field,
293                        _serde::__private::None => {
294                            return _serde::__private::Err(
295                                <__A::Error as _serde::de::Error>::missing_field("position"),
296                            );
297                        }
298                    };
299                    let m_direction = match m_direction {
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                                    "direction",
305                                ),
306                            );
307                        }
308                    };
309                    let m_color = match m_color {
310                        _serde::__private::Some(__field) => __field,
311                        _serde::__private::None => {
312                            return _serde::__private::Err(
313                                <__A::Error as _serde::de::Error>::missing_field("color"),
314                            );
315                        }
316                    };
317                    let m_angle = match m_angle {
318                        _serde::__private::Some(__field) => __field,
319                        _serde::__private::None => {
320                            return _serde::__private::Err(
321                                <__A::Error as _serde::de::Error>::missing_field("angle"),
322                            );
323                        }
324                    };
325                    _serde::__private::Ok(hkxLight {
326                        __ptr,
327                        parent,
328                        m_type,
329                        m_position,
330                        m_direction,
331                        m_color,
332                        m_angle,
333                    })
334                }
335                #[allow(clippy::manual_unwrap_or_default)]
336                fn visit_struct<__A>(
337                    self,
338                    mut __map: __A,
339                ) -> _serde::__private::Result<Self::Value, __A::Error>
340                where
341                    __A: _serde::de::MapAccess<'de>,
342                {
343                    let mut m_type: _serde::__private::Option<LightType> = _serde::__private::None;
344                    let mut m_position: _serde::__private::Option<Vector4> = _serde::__private::None;
345                    let mut m_direction: _serde::__private::Option<Vector4> = _serde::__private::None;
346                    let mut m_color: _serde::__private::Option<u32> = _serde::__private::None;
347                    let mut m_angle: _serde::__private::Option<f32> = _serde::__private::None;
348                    while let _serde::__private::Some(__key) = {
349                        __A::next_key::<__Field>(&mut __map)?
350                    } {
351                        match __key {
352                            __Field::m_type => {
353                                #[cfg(
354                                    any(feature = "strict", feature = "ignore_duplicates")
355                                )]
356                                if _serde::__private::Option::is_some(&m_type) {
357                                    #[cfg(feature = "ignore_duplicates")]
358                                    {
359                                        __A::skip_value(&mut __map)?;
360                                        continue;
361                                    }
362                                    #[cfg(feature = "strict")]
363                                    return _serde::__private::Err(
364                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
365                                    );
366                                }
367                                m_type = _serde::__private::Some(
368                                    match __A::next_value::<LightType>(&mut __map) {
369                                        _serde::__private::Ok(__val) => __val,
370                                        _serde::__private::Err(__err) => {
371                                            return _serde::__private::Err(__err);
372                                        }
373                                    },
374                                );
375                            }
376                            __Field::m_position => {
377                                #[cfg(
378                                    any(feature = "strict", feature = "ignore_duplicates")
379                                )]
380                                if _serde::__private::Option::is_some(&m_position) {
381                                    #[cfg(feature = "ignore_duplicates")]
382                                    {
383                                        __A::skip_value(&mut __map)?;
384                                        continue;
385                                    }
386                                    #[cfg(feature = "strict")]
387                                    return _serde::__private::Err(
388                                        <__A::Error as _serde::de::Error>::duplicate_field(
389                                            "position",
390                                        ),
391                                    );
392                                }
393                                m_position = _serde::__private::Some(
394                                    match __A::next_value::<Vector4>(&mut __map) {
395                                        _serde::__private::Ok(__val) => __val,
396                                        _serde::__private::Err(__err) => {
397                                            return _serde::__private::Err(__err);
398                                        }
399                                    },
400                                );
401                            }
402                            __Field::m_direction => {
403                                #[cfg(
404                                    any(feature = "strict", feature = "ignore_duplicates")
405                                )]
406                                if _serde::__private::Option::is_some(&m_direction) {
407                                    #[cfg(feature = "ignore_duplicates")]
408                                    {
409                                        __A::skip_value(&mut __map)?;
410                                        continue;
411                                    }
412                                    #[cfg(feature = "strict")]
413                                    return _serde::__private::Err(
414                                        <__A::Error as _serde::de::Error>::duplicate_field(
415                                            "direction",
416                                        ),
417                                    );
418                                }
419                                m_direction = _serde::__private::Some(
420                                    match __A::next_value::<Vector4>(&mut __map) {
421                                        _serde::__private::Ok(__val) => __val,
422                                        _serde::__private::Err(__err) => {
423                                            return _serde::__private::Err(__err);
424                                        }
425                                    },
426                                );
427                            }
428                            __Field::m_color => {
429                                #[cfg(
430                                    any(feature = "strict", feature = "ignore_duplicates")
431                                )]
432                                if _serde::__private::Option::is_some(&m_color) {
433                                    #[cfg(feature = "ignore_duplicates")]
434                                    {
435                                        __A::skip_value(&mut __map)?;
436                                        continue;
437                                    }
438                                    #[cfg(feature = "strict")]
439                                    return _serde::__private::Err(
440                                        <__A::Error as _serde::de::Error>::duplicate_field("color"),
441                                    );
442                                }
443                                m_color = _serde::__private::Some(
444                                    match __A::next_value::<u32>(&mut __map) {
445                                        _serde::__private::Ok(__val) => __val,
446                                        _serde::__private::Err(__err) => {
447                                            return _serde::__private::Err(__err);
448                                        }
449                                    },
450                                );
451                            }
452                            __Field::m_angle => {
453                                #[cfg(
454                                    any(feature = "strict", feature = "ignore_duplicates")
455                                )]
456                                if _serde::__private::Option::is_some(&m_angle) {
457                                    #[cfg(feature = "ignore_duplicates")]
458                                    {
459                                        __A::skip_value(&mut __map)?;
460                                        continue;
461                                    }
462                                    #[cfg(feature = "strict")]
463                                    return _serde::__private::Err(
464                                        <__A::Error as _serde::de::Error>::duplicate_field("angle"),
465                                    );
466                                }
467                                m_angle = _serde::__private::Some(
468                                    match __A::next_value::<f32>(&mut __map) {
469                                        _serde::__private::Ok(__val) => __val,
470                                        _serde::__private::Err(__err) => {
471                                            return _serde::__private::Err(__err);
472                                        }
473                                    },
474                                );
475                            }
476                            _ => __A::skip_value(&mut __map)?,
477                        }
478                    }
479                    let m_type = match m_type {
480                        _serde::__private::Some(__field) => __field,
481                        _serde::__private::None => {
482                            #[cfg(feature = "strict")]
483                            return _serde::__private::Err(
484                                <__A::Error as _serde::de::Error>::missing_field("type"),
485                            );
486                            #[cfg(not(feature = "strict"))] Default::default()
487                        }
488                    };
489                    let m_position = match m_position {
490                        _serde::__private::Some(__field) => __field,
491                        _serde::__private::None => {
492                            #[cfg(feature = "strict")]
493                            return _serde::__private::Err(
494                                <__A::Error as _serde::de::Error>::missing_field("position"),
495                            );
496                            #[cfg(not(feature = "strict"))] Default::default()
497                        }
498                    };
499                    let m_direction = match m_direction {
500                        _serde::__private::Some(__field) => __field,
501                        _serde::__private::None => {
502                            #[cfg(feature = "strict")]
503                            return _serde::__private::Err(
504                                <__A::Error as _serde::de::Error>::missing_field(
505                                    "direction",
506                                ),
507                            );
508                            #[cfg(not(feature = "strict"))] Default::default()
509                        }
510                    };
511                    let m_color = match m_color {
512                        _serde::__private::Some(__field) => __field,
513                        _serde::__private::None => {
514                            #[cfg(feature = "strict")]
515                            return _serde::__private::Err(
516                                <__A::Error as _serde::de::Error>::missing_field("color"),
517                            );
518                            #[cfg(not(feature = "strict"))] Default::default()
519                        }
520                    };
521                    let m_angle = match m_angle {
522                        _serde::__private::Some(__field) => __field,
523                        _serde::__private::None => {
524                            #[cfg(feature = "strict")]
525                            return _serde::__private::Err(
526                                <__A::Error as _serde::de::Error>::missing_field("angle"),
527                            );
528                            #[cfg(not(feature = "strict"))] Default::default()
529                        }
530                    };
531                    let __ptr = None;
532                    let parent = hkBaseObject { __ptr };
533                    let parent = hkReferencedObject {
534                        __ptr,
535                        parent,
536                        ..Default::default()
537                    };
538                    let __ptr = __A::class_ptr(&mut __map);
539                    _serde::__private::Ok(hkxLight {
540                        __ptr,
541                        parent,
542                        m_type,
543                        m_position,
544                        m_direction,
545                        m_color,
546                        m_angle,
547                    })
548                }
549            }
550            const FIELDS: &[&str] = &["type", "position", "direction", "color", "angle"];
551            _serde::Deserializer::deserialize_struct(
552                deserializer,
553                "hkxLight",
554                FIELDS,
555                __hkxLightVisitor {
556                    marker: _serde::__private::PhantomData::<hkxLight>,
557                    lifetime: _serde::__private::PhantomData,
558                },
559            )
560        }
561    }
562};
563/// # C++ Info
564/// - name: `LightType`(ctype: `hkEnum<LightType, hkInt8>`)
565#[allow(non_upper_case_globals, non_snake_case)]
566#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
567#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
568#[derive(
569    Debug,
570    Clone,
571    Default,
572    PartialEq,
573    Eq,
574    PartialOrd,
575    Ord,
576    num_derive::ToPrimitive,
577    num_derive::FromPrimitive,
578)]
579pub enum LightType {
580    #[default]
581    POINT_LIGHT = 0isize,
582    DIRECTIONAL_LIGHT = 1isize,
583    SPOT_LIGHT = 2isize,
584}
585const _: () = {
586    use havok_serde as __serde;
587    impl __serde::Serialize for LightType {
588        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
589        where
590            S: __serde::ser::Serializer,
591        {
592            let mut __serializer = __serializer.serialize_enum_flags()?;
593            match self {
594                Self::POINT_LIGHT => __serializer.serialize_field("POINT_LIGHT", &0u64),
595                Self::DIRECTIONAL_LIGHT => {
596                    __serializer.serialize_field("DIRECTIONAL_LIGHT", &1u64)
597                }
598                Self::SPOT_LIGHT => __serializer.serialize_field("SPOT_LIGHT", &2u64),
599            }?;
600            use num_traits::ToPrimitive as _;
601            let num = self
602                .to_i8()
603                .ok_or(S::Error::custom("Failed enum LightType to_i8"))?;
604            __serializer.serialize_bits(&num)?;
605            __serializer.end()
606        }
607    }
608};
609#[doc(hidden)]
610#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
611const _: () = {
612    #[allow(unused_extern_crates, clippy::useless_attribute)]
613    extern crate havok_serde as _serde;
614    #[automatically_derived]
615    impl<'de> _serde::Deserialize<'de> for LightType {
616        fn deserialize<__D>(
617            __deserializer: __D,
618        ) -> _serde::__private::Result<Self, __D::Error>
619        where
620            __D: _serde::Deserializer<'de>,
621        {
622            #[allow(non_camel_case_types)]
623            #[doc(hidden)]
624            enum __Field {
625                __field0,
626                __field1,
627                __field2,
628            }
629            #[doc(hidden)]
630            struct __FieldVisitor;
631            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
632                type Value = __Field;
633                fn expecting(
634                    &self,
635                    __formatter: &mut _serde::__private::Formatter,
636                ) -> _serde::__private::fmt::Result {
637                    _serde::__private::Formatter::write_str(
638                        __formatter,
639                        "variant identifier",
640                    )
641                }
642                fn visit_int8<__E>(
643                    self,
644                    __value: i8,
645                ) -> _serde::__private::Result<Self::Value, __E>
646                where
647                    __E: _serde::de::Error,
648                {
649                    match __value {
650                        0i8 => _serde::__private::Ok(__Field::__field0),
651                        1i8 => _serde::__private::Ok(__Field::__field1),
652                        2i8 => _serde::__private::Ok(__Field::__field2),
653                        _ => {
654                            _serde::__private::Err(
655                                _serde::de::Error::invalid_value(
656                                    _serde::de::Unexpected::Int8(__value),
657                                    &"value(i8) of variant is one of 0, 1, 2",
658                                ),
659                            )
660                        }
661                    }
662                }
663                fn visit_stringptr<__E>(
664                    self,
665                    __value: StringPtr<'de>,
666                ) -> _serde::__private::Result<Self::Value, __E>
667                where
668                    __E: _serde::de::Error,
669                {
670                    if let Some(__value) = __value.into_inner() {
671                        match __value.as_ref() {
672                            v if v == "0" || v.eq_ignore_ascii_case("POINT_LIGHT") => {
673                                _serde::__private::Ok(__Field::__field0)
674                            }
675                            v if v == "1"
676                                || v.eq_ignore_ascii_case("DIRECTIONAL_LIGHT") => {
677                                _serde::__private::Ok(__Field::__field1)
678                            }
679                            v if v == "2" || v.eq_ignore_ascii_case("SPOT_LIGHT") => {
680                                _serde::__private::Ok(__Field::__field2)
681                            }
682                            _ => {
683                                _serde::__private::Err(
684                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
685                                )
686                            }
687                        }
688                    } else {
689                        _serde::__private::Err(
690                            _serde::de::Error::unknown_variant("None", VARIANTS),
691                        )
692                    }
693                }
694            }
695            impl<'de> _serde::Deserialize<'de> for __Field {
696                #[inline]
697                fn deserialize<__D>(
698                    __deserializer: __D,
699                ) -> _serde::__private::Result<Self, __D::Error>
700                where
701                    __D: _serde::Deserializer<'de>,
702                {
703                    _serde::Deserializer::deserialize_identifier(
704                        __deserializer,
705                        _serde::de::ReadEnumSize::Int8,
706                        __FieldVisitor,
707                    )
708                }
709            }
710            #[doc(hidden)]
711            struct __Visitor<'de> {
712                marker: _serde::__private::PhantomData<LightType>,
713                lifetime: _serde::__private::PhantomData<&'de ()>,
714            }
715            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
716                type Value = LightType;
717                fn expecting(
718                    &self,
719                    __formatter: &mut _serde::__private::Formatter,
720                ) -> _serde::__private::fmt::Result {
721                    _serde::__private::Formatter::write_str(
722                        __formatter,
723                        "enum LightType",
724                    )
725                }
726                fn visit_enum<__A>(
727                    self,
728                    __data: __A,
729                ) -> _serde::__private::Result<Self::Value, __A::Error>
730                where
731                    __A: _serde::de::EnumAccess<'de>,
732                {
733                    match _serde::de::EnumAccess::variant(__data)? {
734                        (__Field::__field0, __variant) => {
735                            _serde::de::VariantAccess::unit_variant(__variant)?;
736                            _serde::__private::Ok(LightType::POINT_LIGHT)
737                        }
738                        (__Field::__field1, __variant) => {
739                            _serde::de::VariantAccess::unit_variant(__variant)?;
740                            _serde::__private::Ok(LightType::DIRECTIONAL_LIGHT)
741                        }
742                        (__Field::__field2, __variant) => {
743                            _serde::de::VariantAccess::unit_variant(__variant)?;
744                            _serde::__private::Ok(LightType::SPOT_LIGHT)
745                        }
746                    }
747                }
748            }
749            #[doc(hidden)]
750            const VARIANTS: &'static [&'static str] = &[
751                "POINT_LIGHT",
752                "DIRECTIONAL_LIGHT",
753                "SPOT_LIGHT",
754            ];
755            _serde::Deserializer::deserialize_enum(
756                __deserializer,
757                "LightType",
758                VARIANTS,
759                __Visitor {
760                    marker: _serde::__private::PhantomData::<LightType>,
761                    lifetime: _serde::__private::PhantomData,
762                },
763            )
764        }
765    }
766};
havok_classes/generated/hkxLight_.rs

havok_classes/generated/
hkxLight_.rs
