havok_classes/generated/
hkbCompiledExpressionSetToken_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbCompiledExpressionSetToken`
5/// - version: `0`
6/// - signature: `0xc6aaccc8`
7/// - size: `  8`(x86)/`  8`(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 hkbCompiledExpressionSetToken {
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: `data`(ctype: `hkReal`)
28    /// - offset: `  0`(x86)/`  0`(x86_64)
29    /// - type_size: `  4`(x86)/`  4`(x86_64)
30    #[cfg_attr(feature = "json_schema", schemars(rename = "data"))]
31    #[cfg_attr(feature = "serde", serde(rename = "data"))]
32    pub m_data: f32,
33    /// # C++ Info
34    /// - name: `type`(ctype: `enum TokenType`)
35    /// - offset: `  4`(x86)/`  4`(x86_64)
36    /// - type_size: `  1`(x86)/`  1`(x86_64)
37    #[cfg_attr(feature = "json_schema", schemars(rename = "type"))]
38    #[cfg_attr(feature = "serde", serde(rename = "type"))]
39    pub m_type: TokenType,
40    /// # C++ Info
41    /// - name: `operator`(ctype: `enum Operator`)
42    /// - offset: `  5`(x86)/`  5`(x86_64)
43    /// - type_size: `  1`(x86)/`  1`(x86_64)
44    #[cfg_attr(feature = "json_schema", schemars(rename = "operator"))]
45    #[cfg_attr(feature = "serde", serde(rename = "operator"))]
46    pub m_operator: Operator,
47}
48const _: () = {
49    use havok_serde as _serde;
50    impl _serde::HavokClass for hkbCompiledExpressionSetToken {
51        #[inline]
52        fn name(&self) -> &'static str {
53            "hkbCompiledExpressionSetToken"
54        }
55        #[inline]
56        fn signature(&self) -> _serde::__private::Signature {
57            _serde::__private::Signature::new(0xc6aaccc8)
58        }
59        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
60        fn deps_indexes(&self) -> Vec<usize> {
61            let mut v = Vec::new();
62            v
63        }
64    }
65    impl _serde::Serialize for hkbCompiledExpressionSetToken {
66        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
67        where
68            S: _serde::ser::Serializer,
69        {
70            let class_meta = self
71                .__ptr
72                .map(|name| (name, _serde::__private::Signature::new(0xc6aaccc8)));
73            let mut serializer = __serializer
74                .serialize_struct(
75                    "hkbCompiledExpressionSetToken",
76                    class_meta,
77                    (8u64, 8u64),
78                )?;
79            serializer.serialize_field("data", &self.m_data)?;
80            serializer.serialize_field("type", &self.m_type)?;
81            serializer.serialize_field("operator", &self.m_operator)?;
82            serializer.pad_field([0u8; 2usize].as_slice(), [0u8; 2usize].as_slice())?;
83            serializer.end()
84        }
85    }
86};
87#[doc(hidden)]
88#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
89const _: () = {
90    use havok_serde as _serde;
91    #[automatically_derived]
92    impl<'de> _serde::Deserialize<'de> for hkbCompiledExpressionSetToken {
93        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
94        where
95            __D: _serde::Deserializer<'de>,
96        {
97            #[allow(non_camel_case_types)]
98            enum __Field {
99                m_data,
100                m_type,
101                m_operator,
102                __ignore,
103            }
104            struct __FieldVisitor;
105            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
106                type Value = __Field;
107                fn expecting(
108                    &self,
109                    __formatter: &mut core::fmt::Formatter,
110                ) -> core::fmt::Result {
111                    core::fmt::Formatter::write_str(__formatter, "field identifier")
112                }
113                /// Intended for use in XML.
114                #[allow(clippy::match_single_binding)]
115                #[allow(clippy::reversed_empty_ranges)]
116                #[allow(clippy::single_match)]
117                fn visit_key<__E>(
118                    self,
119                    __value: &str,
120                ) -> core::result::Result<Self::Value, __E>
121                where
122                    __E: _serde::de::Error,
123                {
124                    match __value {
125                        "data" => Ok(__Field::m_data),
126                        "type" => Ok(__Field::m_type),
127                        "operator" => Ok(__Field::m_operator),
128                        _ => Ok(__Field::__ignore),
129                    }
130                }
131            }
132            impl<'de> _serde::Deserialize<'de> for __Field {
133                #[inline]
134                fn deserialize<__D>(
135                    __deserializer: __D,
136                ) -> core::result::Result<Self, __D::Error>
137                where
138                    __D: _serde::Deserializer<'de>,
139                {
140                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
141                }
142            }
143            struct __hkbCompiledExpressionSetTokenVisitor<'de> {
144                marker: _serde::__private::PhantomData<hkbCompiledExpressionSetToken>,
145                lifetime: _serde::__private::PhantomData<&'de ()>,
146            }
147            #[allow(clippy::match_single_binding)]
148            #[allow(clippy::reversed_empty_ranges)]
149            #[allow(clippy::single_match)]
150            impl<'de> _serde::de::Visitor<'de>
151            for __hkbCompiledExpressionSetTokenVisitor<'de> {
152                type Value = hkbCompiledExpressionSetToken;
153                fn expecting(
154                    &self,
155                    __formatter: &mut core::fmt::Formatter,
156                ) -> core::fmt::Result {
157                    core::fmt::Formatter::write_str(
158                        __formatter,
159                        "struct hkbCompiledExpressionSetToken",
160                    )
161                }
162                fn visit_struct_for_bytes<__A>(
163                    self,
164                    mut __map: __A,
165                ) -> _serde::__private::Result<Self::Value, __A::Error>
166                where
167                    __A: _serde::de::MapAccess<'de>,
168                {
169                    let __ptr = __A::class_ptr(&mut __map);
170                    let mut m_data: _serde::__private::Option<f32> = _serde::__private::None;
171                    let mut m_type: _serde::__private::Option<TokenType> = _serde::__private::None;
172                    let mut m_operator: _serde::__private::Option<Operator> = _serde::__private::None;
173                    for i in 0..3usize {
174                        match i {
175                            0usize => {
176                                if _serde::__private::Option::is_some(&m_data) {
177                                    return _serde::__private::Err(
178                                        <__A::Error as _serde::de::Error>::duplicate_field("data"),
179                                    );
180                                }
181                                m_data = _serde::__private::Some(
182                                    match __A::next_value::<f32>(&mut __map) {
183                                        _serde::__private::Ok(__val) => __val,
184                                        _serde::__private::Err(__err) => {
185                                            return _serde::__private::Err(__err);
186                                        }
187                                    },
188                                );
189                            }
190                            1usize => {
191                                if _serde::__private::Option::is_some(&m_type) {
192                                    return _serde::__private::Err(
193                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
194                                    );
195                                }
196                                m_type = _serde::__private::Some(
197                                    match __A::next_value::<TokenType>(&mut __map) {
198                                        _serde::__private::Ok(__val) => __val,
199                                        _serde::__private::Err(__err) => {
200                                            return _serde::__private::Err(__err);
201                                        }
202                                    },
203                                );
204                            }
205                            2usize => {
206                                if _serde::__private::Option::is_some(&m_operator) {
207                                    return _serde::__private::Err(
208                                        <__A::Error as _serde::de::Error>::duplicate_field(
209                                            "operator",
210                                        ),
211                                    );
212                                }
213                                m_operator = _serde::__private::Some(
214                                    match __A::next_value::<Operator>(&mut __map) {
215                                        _serde::__private::Ok(__val) => __val,
216                                        _serde::__private::Err(__err) => {
217                                            return _serde::__private::Err(__err);
218                                        }
219                                    },
220                                );
221                            }
222                            _ => {}
223                        }
224                    }
225                    __A::pad(&mut __map, 2usize, 2usize)?;
226                    let m_data = match m_data {
227                        _serde::__private::Some(__field) => __field,
228                        _serde::__private::None => {
229                            return _serde::__private::Err(
230                                <__A::Error as _serde::de::Error>::missing_field("data"),
231                            );
232                        }
233                    };
234                    let m_type = match m_type {
235                        _serde::__private::Some(__field) => __field,
236                        _serde::__private::None => {
237                            return _serde::__private::Err(
238                                <__A::Error as _serde::de::Error>::missing_field("type"),
239                            );
240                        }
241                    };
242                    let m_operator = match m_operator {
243                        _serde::__private::Some(__field) => __field,
244                        _serde::__private::None => {
245                            return _serde::__private::Err(
246                                <__A::Error as _serde::de::Error>::missing_field("operator"),
247                            );
248                        }
249                    };
250                    _serde::__private::Ok(hkbCompiledExpressionSetToken {
251                        __ptr,
252                        m_data,
253                        m_type,
254                        m_operator,
255                    })
256                }
257                #[allow(clippy::manual_unwrap_or_default)]
258                fn visit_struct<__A>(
259                    self,
260                    mut __map: __A,
261                ) -> _serde::__private::Result<Self::Value, __A::Error>
262                where
263                    __A: _serde::de::MapAccess<'de>,
264                {
265                    let mut m_data: _serde::__private::Option<f32> = _serde::__private::None;
266                    let mut m_type: _serde::__private::Option<TokenType> = _serde::__private::None;
267                    let mut m_operator: _serde::__private::Option<Operator> = _serde::__private::None;
268                    while let _serde::__private::Some(__key) = {
269                        __A::next_key::<__Field>(&mut __map)?
270                    } {
271                        match __key {
272                            __Field::m_data => {
273                                #[cfg(
274                                    any(feature = "strict", feature = "ignore_duplicates")
275                                )]
276                                if _serde::__private::Option::is_some(&m_data) {
277                                    #[cfg(feature = "ignore_duplicates")]
278                                    {
279                                        __A::skip_value(&mut __map)?;
280                                        continue;
281                                    }
282                                    #[cfg(feature = "strict")]
283                                    return _serde::__private::Err(
284                                        <__A::Error as _serde::de::Error>::duplicate_field("data"),
285                                    );
286                                }
287                                m_data = _serde::__private::Some(
288                                    match __A::next_value::<f32>(&mut __map) {
289                                        _serde::__private::Ok(__val) => __val,
290                                        _serde::__private::Err(__err) => {
291                                            return _serde::__private::Err(__err);
292                                        }
293                                    },
294                                );
295                            }
296                            __Field::m_type => {
297                                #[cfg(
298                                    any(feature = "strict", feature = "ignore_duplicates")
299                                )]
300                                if _serde::__private::Option::is_some(&m_type) {
301                                    #[cfg(feature = "ignore_duplicates")]
302                                    {
303                                        __A::skip_value(&mut __map)?;
304                                        continue;
305                                    }
306                                    #[cfg(feature = "strict")]
307                                    return _serde::__private::Err(
308                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
309                                    );
310                                }
311                                m_type = _serde::__private::Some(
312                                    match __A::next_value::<TokenType>(&mut __map) {
313                                        _serde::__private::Ok(__val) => __val,
314                                        _serde::__private::Err(__err) => {
315                                            return _serde::__private::Err(__err);
316                                        }
317                                    },
318                                );
319                            }
320                            __Field::m_operator => {
321                                #[cfg(
322                                    any(feature = "strict", feature = "ignore_duplicates")
323                                )]
324                                if _serde::__private::Option::is_some(&m_operator) {
325                                    #[cfg(feature = "ignore_duplicates")]
326                                    {
327                                        __A::skip_value(&mut __map)?;
328                                        continue;
329                                    }
330                                    #[cfg(feature = "strict")]
331                                    return _serde::__private::Err(
332                                        <__A::Error as _serde::de::Error>::duplicate_field(
333                                            "operator",
334                                        ),
335                                    );
336                                }
337                                m_operator = _serde::__private::Some(
338                                    match __A::next_value::<Operator>(&mut __map) {
339                                        _serde::__private::Ok(__val) => __val,
340                                        _serde::__private::Err(__err) => {
341                                            return _serde::__private::Err(__err);
342                                        }
343                                    },
344                                );
345                            }
346                            _ => __A::skip_value(&mut __map)?,
347                        }
348                    }
349                    let m_data = match m_data {
350                        _serde::__private::Some(__field) => __field,
351                        _serde::__private::None => {
352                            #[cfg(feature = "strict")]
353                            return _serde::__private::Err(
354                                <__A::Error as _serde::de::Error>::missing_field("data"),
355                            );
356                            #[cfg(not(feature = "strict"))] Default::default()
357                        }
358                    };
359                    let m_type = match m_type {
360                        _serde::__private::Some(__field) => __field,
361                        _serde::__private::None => {
362                            #[cfg(feature = "strict")]
363                            return _serde::__private::Err(
364                                <__A::Error as _serde::de::Error>::missing_field("type"),
365                            );
366                            #[cfg(not(feature = "strict"))] Default::default()
367                        }
368                    };
369                    let m_operator = match m_operator {
370                        _serde::__private::Some(__field) => __field,
371                        _serde::__private::None => {
372                            #[cfg(feature = "strict")]
373                            return _serde::__private::Err(
374                                <__A::Error as _serde::de::Error>::missing_field("operator"),
375                            );
376                            #[cfg(not(feature = "strict"))] Default::default()
377                        }
378                    };
379                    let __ptr = __A::class_ptr(&mut __map);
380                    _serde::__private::Ok(hkbCompiledExpressionSetToken {
381                        __ptr,
382                        m_data,
383                        m_type,
384                        m_operator,
385                    })
386                }
387            }
388            const FIELDS: &[&str] = &["data", "type", "operator"];
389            _serde::Deserializer::deserialize_struct(
390                deserializer,
391                "hkbCompiledExpressionSetToken",
392                FIELDS,
393                __hkbCompiledExpressionSetTokenVisitor {
394                    marker: _serde::__private::PhantomData::<
395                        hkbCompiledExpressionSetToken,
396                    >,
397                    lifetime: _serde::__private::PhantomData,
398                },
399            )
400        }
401    }
402};
403/// # C++ Info
404/// - name: `TokenType`(ctype: `hkEnum<TokenType, hkInt8>`)
405#[allow(non_upper_case_globals, non_snake_case)]
406#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
407#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
408#[derive(
409    Debug,
410    Clone,
411    Default,
412    PartialEq,
413    Eq,
414    PartialOrd,
415    Ord,
416    num_derive::ToPrimitive,
417    num_derive::FromPrimitive,
418)]
419pub enum TokenType {
420    #[default]
421    TOKEN_TYPE_NONE = 0isize,
422    TOKEN_TYPE_OPERATOR = 1isize,
423    TOKEN_TYPE_NUMBER = 2isize,
424    TOKEN_TYPE_VARIABLE_INDEX = 3isize,
425    TOKEN_TYPE_OPENING_PAREN = 4isize,
426    TOKEN_TYPE_CLOSING_PAREN = 5isize,
427    TOKEN_TYPE_COMMA = 6isize,
428    TOKEN_TYPE_CHARACTER_PROPERTY_INDEX = 7isize,
429}
430/// # C++ Info
431/// - name: `Operator`(ctype: `hkEnum<Operator, hkInt8>`)
432#[allow(non_upper_case_globals, non_snake_case)]
433#[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
434#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
435#[derive(
436    Debug,
437    Clone,
438    Default,
439    PartialEq,
440    Eq,
441    PartialOrd,
442    Ord,
443    num_derive::ToPrimitive,
444    num_derive::FromPrimitive,
445)]
446pub enum Operator {
447    #[default]
448    OP_NOP = 0isize,
449    OP_RAND01 = 1isize,
450    OP_LOGICAL_NOT = 2isize,
451    OP_UNARY_MINUS = 3isize,
452    OP_UNARY_PLUS = 4isize,
453    OP_SIN = 5isize,
454    OP_COS = 6isize,
455    OP_ASIN = 7isize,
456    OP_ACOS = 8isize,
457    OP_SQRT = 9isize,
458    OP_FABS = 10isize,
459    OP_CEIL = 11isize,
460    OP_FLOOR = 12isize,
461    OP_SQRTINV = 13isize,
462    OP_MUL = 14isize,
463    OP_DIV = 15isize,
464    OP_ADD = 16isize,
465    OP_SUB = 17isize,
466    OP_LOGICAL_OR = 18isize,
467    OP_LOGICAL_AND = 19isize,
468    OP_EQ = 20isize,
469    OP_NEQ = 21isize,
470    OP_LT = 22isize,
471    OP_GT = 23isize,
472    OP_LEQ = 24isize,
473    OP_GEQ = 25isize,
474    OP_POW = 26isize,
475    OP_MAX2 = 27isize,
476    OP_MIN2 = 28isize,
477    OP_RANDRANGE = 29isize,
478    OP_ATAN2APPROX = 30isize,
479    OP_CLAMP = 31isize,
480    OP_MOD = 32isize,
481    OP_DEG2RAD = 33isize,
482    OP_RAD2DEG = 34isize,
483    OP_COSD = 35isize,
484    OP_SIND = 36isize,
485    OP_ACOSD = 37isize,
486    OP_ASIND = 38isize,
487    OP_ATAN2APPROXD = 39isize,
488    OP_SIGN = 40isize,
489    OP_LERP = 41isize,
490    OP_CLERP = 42isize,
491    OP_COND = 43isize,
492}
493const _: () = {
494    use havok_serde as __serde;
495    impl __serde::Serialize for TokenType {
496        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
497        where
498            S: __serde::ser::Serializer,
499        {
500            let mut __serializer = __serializer.serialize_enum_flags()?;
501            match self {
502                Self::TOKEN_TYPE_NONE => {
503                    __serializer.serialize_field("TOKEN_TYPE_NONE", &0u64)
504                }
505                Self::TOKEN_TYPE_OPERATOR => {
506                    __serializer.serialize_field("TOKEN_TYPE_OPERATOR", &1u64)
507                }
508                Self::TOKEN_TYPE_NUMBER => {
509                    __serializer.serialize_field("TOKEN_TYPE_NUMBER", &2u64)
510                }
511                Self::TOKEN_TYPE_VARIABLE_INDEX => {
512                    __serializer.serialize_field("TOKEN_TYPE_VARIABLE_INDEX", &3u64)
513                }
514                Self::TOKEN_TYPE_OPENING_PAREN => {
515                    __serializer.serialize_field("TOKEN_TYPE_OPENING_PAREN", &4u64)
516                }
517                Self::TOKEN_TYPE_CLOSING_PAREN => {
518                    __serializer.serialize_field("TOKEN_TYPE_CLOSING_PAREN", &5u64)
519                }
520                Self::TOKEN_TYPE_COMMA => {
521                    __serializer.serialize_field("TOKEN_TYPE_COMMA", &6u64)
522                }
523                Self::TOKEN_TYPE_CHARACTER_PROPERTY_INDEX => {
524                    __serializer
525                        .serialize_field("TOKEN_TYPE_CHARACTER_PROPERTY_INDEX", &7u64)
526                }
527            }?;
528            use num_traits::ToPrimitive as _;
529            let num = self
530                .to_i8()
531                .ok_or(S::Error::custom("Failed enum TokenType to_i8"))?;
532            __serializer.serialize_bits(&num)?;
533            __serializer.end()
534        }
535    }
536};
537const _: () = {
538    use havok_serde as __serde;
539    impl __serde::Serialize for Operator {
540        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
541        where
542            S: __serde::ser::Serializer,
543        {
544            let mut __serializer = __serializer.serialize_enum_flags()?;
545            match self {
546                Self::OP_NOP => __serializer.serialize_field("OP_NOP", &0u64),
547                Self::OP_RAND01 => __serializer.serialize_field("OP_RAND01", &1u64),
548                Self::OP_LOGICAL_NOT => {
549                    __serializer.serialize_field("OP_LOGICAL_NOT", &2u64)
550                }
551                Self::OP_UNARY_MINUS => {
552                    __serializer.serialize_field("OP_UNARY_MINUS", &3u64)
553                }
554                Self::OP_UNARY_PLUS => {
555                    __serializer.serialize_field("OP_UNARY_PLUS", &4u64)
556                }
557                Self::OP_SIN => __serializer.serialize_field("OP_SIN", &5u64),
558                Self::OP_COS => __serializer.serialize_field("OP_COS", &6u64),
559                Self::OP_ASIN => __serializer.serialize_field("OP_ASIN", &7u64),
560                Self::OP_ACOS => __serializer.serialize_field("OP_ACOS", &8u64),
561                Self::OP_SQRT => __serializer.serialize_field("OP_SQRT", &9u64),
562                Self::OP_FABS => __serializer.serialize_field("OP_FABS", &10u64),
563                Self::OP_CEIL => __serializer.serialize_field("OP_CEIL", &11u64),
564                Self::OP_FLOOR => __serializer.serialize_field("OP_FLOOR", &12u64),
565                Self::OP_SQRTINV => __serializer.serialize_field("OP_SQRTINV", &13u64),
566                Self::OP_MUL => __serializer.serialize_field("OP_MUL", &14u64),
567                Self::OP_DIV => __serializer.serialize_field("OP_DIV", &15u64),
568                Self::OP_ADD => __serializer.serialize_field("OP_ADD", &16u64),
569                Self::OP_SUB => __serializer.serialize_field("OP_SUB", &17u64),
570                Self::OP_LOGICAL_OR => {
571                    __serializer.serialize_field("OP_LOGICAL_OR", &18u64)
572                }
573                Self::OP_LOGICAL_AND => {
574                    __serializer.serialize_field("OP_LOGICAL_AND", &19u64)
575                }
576                Self::OP_EQ => __serializer.serialize_field("OP_EQ", &20u64),
577                Self::OP_NEQ => __serializer.serialize_field("OP_NEQ", &21u64),
578                Self::OP_LT => __serializer.serialize_field("OP_LT", &22u64),
579                Self::OP_GT => __serializer.serialize_field("OP_GT", &23u64),
580                Self::OP_LEQ => __serializer.serialize_field("OP_LEQ", &24u64),
581                Self::OP_GEQ => __serializer.serialize_field("OP_GEQ", &25u64),
582                Self::OP_POW => __serializer.serialize_field("OP_POW", &26u64),
583                Self::OP_MAX2 => __serializer.serialize_field("OP_MAX2", &27u64),
584                Self::OP_MIN2 => __serializer.serialize_field("OP_MIN2", &28u64),
585                Self::OP_RANDRANGE => {
586                    __serializer.serialize_field("OP_RANDRANGE", &29u64)
587                }
588                Self::OP_ATAN2APPROX => {
589                    __serializer.serialize_field("OP_ATAN2APPROX", &30u64)
590                }
591                Self::OP_CLAMP => __serializer.serialize_field("OP_CLAMP", &31u64),
592                Self::OP_MOD => __serializer.serialize_field("OP_MOD", &32u64),
593                Self::OP_DEG2RAD => __serializer.serialize_field("OP_DEG2RAD", &33u64),
594                Self::OP_RAD2DEG => __serializer.serialize_field("OP_RAD2DEG", &34u64),
595                Self::OP_COSD => __serializer.serialize_field("OP_COSD", &35u64),
596                Self::OP_SIND => __serializer.serialize_field("OP_SIND", &36u64),
597                Self::OP_ACOSD => __serializer.serialize_field("OP_ACOSD", &37u64),
598                Self::OP_ASIND => __serializer.serialize_field("OP_ASIND", &38u64),
599                Self::OP_ATAN2APPROXD => {
600                    __serializer.serialize_field("OP_ATAN2APPROXD", &39u64)
601                }
602                Self::OP_SIGN => __serializer.serialize_field("OP_SIGN", &40u64),
603                Self::OP_LERP => __serializer.serialize_field("OP_LERP", &41u64),
604                Self::OP_CLERP => __serializer.serialize_field("OP_CLERP", &42u64),
605                Self::OP_COND => __serializer.serialize_field("OP_COND", &43u64),
606            }?;
607            use num_traits::ToPrimitive as _;
608            let num = self
609                .to_i8()
610                .ok_or(S::Error::custom("Failed enum Operator to_i8"))?;
611            __serializer.serialize_bits(&num)?;
612            __serializer.end()
613        }
614    }
615};
616#[doc(hidden)]
617#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
618const _: () = {
619    #[allow(unused_extern_crates, clippy::useless_attribute)]
620    extern crate havok_serde as _serde;
621    #[automatically_derived]
622    impl<'de> _serde::Deserialize<'de> for TokenType {
623        fn deserialize<__D>(
624            __deserializer: __D,
625        ) -> _serde::__private::Result<Self, __D::Error>
626        where
627            __D: _serde::Deserializer<'de>,
628        {
629            #[allow(non_camel_case_types)]
630            #[doc(hidden)]
631            enum __Field {
632                __field0,
633                __field1,
634                __field2,
635                __field3,
636                __field4,
637                __field5,
638                __field6,
639                __field7,
640            }
641            #[doc(hidden)]
642            struct __FieldVisitor;
643            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
644                type Value = __Field;
645                fn expecting(
646                    &self,
647                    __formatter: &mut _serde::__private::Formatter,
648                ) -> _serde::__private::fmt::Result {
649                    _serde::__private::Formatter::write_str(
650                        __formatter,
651                        "variant identifier",
652                    )
653                }
654                fn visit_int8<__E>(
655                    self,
656                    __value: i8,
657                ) -> _serde::__private::Result<Self::Value, __E>
658                where
659                    __E: _serde::de::Error,
660                {
661                    match __value {
662                        0i8 => _serde::__private::Ok(__Field::__field0),
663                        1i8 => _serde::__private::Ok(__Field::__field1),
664                        2i8 => _serde::__private::Ok(__Field::__field2),
665                        3i8 => _serde::__private::Ok(__Field::__field3),
666                        4i8 => _serde::__private::Ok(__Field::__field4),
667                        5i8 => _serde::__private::Ok(__Field::__field5),
668                        6i8 => _serde::__private::Ok(__Field::__field6),
669                        7i8 => _serde::__private::Ok(__Field::__field7),
670                        _ => {
671                            _serde::__private::Err(
672                                _serde::de::Error::invalid_value(
673                                    _serde::de::Unexpected::Int8(__value),
674                                    &"value(i8) of variant is one of 0, 1, 2, 3, 4, 5, 6, 7",
675                                ),
676                            )
677                        }
678                    }
679                }
680                fn visit_stringptr<__E>(
681                    self,
682                    __value: StringPtr<'de>,
683                ) -> _serde::__private::Result<Self::Value, __E>
684                where
685                    __E: _serde::de::Error,
686                {
687                    if let Some(__value) = __value.into_inner() {
688                        match __value.as_ref() {
689                            v if v == "0"
690                                || v.eq_ignore_ascii_case("TOKEN_TYPE_NONE") => {
691                                _serde::__private::Ok(__Field::__field0)
692                            }
693                            v if v == "1"
694                                || v.eq_ignore_ascii_case("TOKEN_TYPE_OPERATOR") => {
695                                _serde::__private::Ok(__Field::__field1)
696                            }
697                            v if v == "2"
698                                || v.eq_ignore_ascii_case("TOKEN_TYPE_NUMBER") => {
699                                _serde::__private::Ok(__Field::__field2)
700                            }
701                            v if v == "3"
702                                || v.eq_ignore_ascii_case("TOKEN_TYPE_VARIABLE_INDEX") => {
703                                _serde::__private::Ok(__Field::__field3)
704                            }
705                            v if v == "4"
706                                || v.eq_ignore_ascii_case("TOKEN_TYPE_OPENING_PAREN") => {
707                                _serde::__private::Ok(__Field::__field4)
708                            }
709                            v if v == "5"
710                                || v.eq_ignore_ascii_case("TOKEN_TYPE_CLOSING_PAREN") => {
711                                _serde::__private::Ok(__Field::__field5)
712                            }
713                            v if v == "6"
714                                || v.eq_ignore_ascii_case("TOKEN_TYPE_COMMA") => {
715                                _serde::__private::Ok(__Field::__field6)
716                            }
717                            v if v == "7"
718                                || v
719                                    .eq_ignore_ascii_case(
720                                        "TOKEN_TYPE_CHARACTER_PROPERTY_INDEX",
721                                    ) => _serde::__private::Ok(__Field::__field7),
722                            _ => {
723                                _serde::__private::Err(
724                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
725                                )
726                            }
727                        }
728                    } else {
729                        _serde::__private::Err(
730                            _serde::de::Error::unknown_variant("None", VARIANTS),
731                        )
732                    }
733                }
734            }
735            impl<'de> _serde::Deserialize<'de> for __Field {
736                #[inline]
737                fn deserialize<__D>(
738                    __deserializer: __D,
739                ) -> _serde::__private::Result<Self, __D::Error>
740                where
741                    __D: _serde::Deserializer<'de>,
742                {
743                    _serde::Deserializer::deserialize_identifier(
744                        __deserializer,
745                        _serde::de::ReadEnumSize::Int8,
746                        __FieldVisitor,
747                    )
748                }
749            }
750            #[doc(hidden)]
751            struct __Visitor<'de> {
752                marker: _serde::__private::PhantomData<TokenType>,
753                lifetime: _serde::__private::PhantomData<&'de ()>,
754            }
755            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
756                type Value = TokenType;
757                fn expecting(
758                    &self,
759                    __formatter: &mut _serde::__private::Formatter,
760                ) -> _serde::__private::fmt::Result {
761                    _serde::__private::Formatter::write_str(
762                        __formatter,
763                        "enum TokenType",
764                    )
765                }
766                fn visit_enum<__A>(
767                    self,
768                    __data: __A,
769                ) -> _serde::__private::Result<Self::Value, __A::Error>
770                where
771                    __A: _serde::de::EnumAccess<'de>,
772                {
773                    match _serde::de::EnumAccess::variant(__data)? {
774                        (__Field::__field0, __variant) => {
775                            _serde::de::VariantAccess::unit_variant(__variant)?;
776                            _serde::__private::Ok(TokenType::TOKEN_TYPE_NONE)
777                        }
778                        (__Field::__field1, __variant) => {
779                            _serde::de::VariantAccess::unit_variant(__variant)?;
780                            _serde::__private::Ok(TokenType::TOKEN_TYPE_OPERATOR)
781                        }
782                        (__Field::__field2, __variant) => {
783                            _serde::de::VariantAccess::unit_variant(__variant)?;
784                            _serde::__private::Ok(TokenType::TOKEN_TYPE_NUMBER)
785                        }
786                        (__Field::__field3, __variant) => {
787                            _serde::de::VariantAccess::unit_variant(__variant)?;
788                            _serde::__private::Ok(TokenType::TOKEN_TYPE_VARIABLE_INDEX)
789                        }
790                        (__Field::__field4, __variant) => {
791                            _serde::de::VariantAccess::unit_variant(__variant)?;
792                            _serde::__private::Ok(TokenType::TOKEN_TYPE_OPENING_PAREN)
793                        }
794                        (__Field::__field5, __variant) => {
795                            _serde::de::VariantAccess::unit_variant(__variant)?;
796                            _serde::__private::Ok(TokenType::TOKEN_TYPE_CLOSING_PAREN)
797                        }
798                        (__Field::__field6, __variant) => {
799                            _serde::de::VariantAccess::unit_variant(__variant)?;
800                            _serde::__private::Ok(TokenType::TOKEN_TYPE_COMMA)
801                        }
802                        (__Field::__field7, __variant) => {
803                            _serde::de::VariantAccess::unit_variant(__variant)?;
804                            _serde::__private::Ok(
805                                TokenType::TOKEN_TYPE_CHARACTER_PROPERTY_INDEX,
806                            )
807                        }
808                    }
809                }
810            }
811            #[doc(hidden)]
812            const VARIANTS: &'static [&'static str] = &[
813                "TOKEN_TYPE_NONE",
814                "TOKEN_TYPE_OPERATOR",
815                "TOKEN_TYPE_NUMBER",
816                "TOKEN_TYPE_VARIABLE_INDEX",
817                "TOKEN_TYPE_OPENING_PAREN",
818                "TOKEN_TYPE_CLOSING_PAREN",
819                "TOKEN_TYPE_COMMA",
820                "TOKEN_TYPE_CHARACTER_PROPERTY_INDEX",
821            ];
822            _serde::Deserializer::deserialize_enum(
823                __deserializer,
824                "TokenType",
825                VARIANTS,
826                __Visitor {
827                    marker: _serde::__private::PhantomData::<TokenType>,
828                    lifetime: _serde::__private::PhantomData,
829                },
830            )
831        }
832    }
833};
834#[doc(hidden)]
835#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
836const _: () = {
837    #[allow(unused_extern_crates, clippy::useless_attribute)]
838    extern crate havok_serde as _serde;
839    #[automatically_derived]
840    impl<'de> _serde::Deserialize<'de> for Operator {
841        fn deserialize<__D>(
842            __deserializer: __D,
843        ) -> _serde::__private::Result<Self, __D::Error>
844        where
845            __D: _serde::Deserializer<'de>,
846        {
847            #[allow(non_camel_case_types)]
848            #[doc(hidden)]
849            enum __Field {
850                __field0,
851                __field1,
852                __field2,
853                __field3,
854                __field4,
855                __field5,
856                __field6,
857                __field7,
858                __field8,
859                __field9,
860                __field10,
861                __field11,
862                __field12,
863                __field13,
864                __field14,
865                __field15,
866                __field16,
867                __field17,
868                __field18,
869                __field19,
870                __field20,
871                __field21,
872                __field22,
873                __field23,
874                __field24,
875                __field25,
876                __field26,
877                __field27,
878                __field28,
879                __field29,
880                __field30,
881                __field31,
882                __field32,
883                __field33,
884                __field34,
885                __field35,
886                __field36,
887                __field37,
888                __field38,
889                __field39,
890                __field40,
891                __field41,
892                __field42,
893                __field43,
894            }
895            #[doc(hidden)]
896            struct __FieldVisitor;
897            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
898                type Value = __Field;
899                fn expecting(
900                    &self,
901                    __formatter: &mut _serde::__private::Formatter,
902                ) -> _serde::__private::fmt::Result {
903                    _serde::__private::Formatter::write_str(
904                        __formatter,
905                        "variant identifier",
906                    )
907                }
908                fn visit_int8<__E>(
909                    self,
910                    __value: i8,
911                ) -> _serde::__private::Result<Self::Value, __E>
912                where
913                    __E: _serde::de::Error,
914                {
915                    match __value {
916                        0i8 => _serde::__private::Ok(__Field::__field0),
917                        1i8 => _serde::__private::Ok(__Field::__field1),
918                        2i8 => _serde::__private::Ok(__Field::__field2),
919                        3i8 => _serde::__private::Ok(__Field::__field3),
920                        4i8 => _serde::__private::Ok(__Field::__field4),
921                        5i8 => _serde::__private::Ok(__Field::__field5),
922                        6i8 => _serde::__private::Ok(__Field::__field6),
923                        7i8 => _serde::__private::Ok(__Field::__field7),
924                        8i8 => _serde::__private::Ok(__Field::__field8),
925                        9i8 => _serde::__private::Ok(__Field::__field9),
926                        10i8 => _serde::__private::Ok(__Field::__field10),
927                        11i8 => _serde::__private::Ok(__Field::__field11),
928                        12i8 => _serde::__private::Ok(__Field::__field12),
929                        13i8 => _serde::__private::Ok(__Field::__field13),
930                        14i8 => _serde::__private::Ok(__Field::__field14),
931                        15i8 => _serde::__private::Ok(__Field::__field15),
932                        16i8 => _serde::__private::Ok(__Field::__field16),
933                        17i8 => _serde::__private::Ok(__Field::__field17),
934                        18i8 => _serde::__private::Ok(__Field::__field18),
935                        19i8 => _serde::__private::Ok(__Field::__field19),
936                        20i8 => _serde::__private::Ok(__Field::__field20),
937                        21i8 => _serde::__private::Ok(__Field::__field21),
938                        22i8 => _serde::__private::Ok(__Field::__field22),
939                        23i8 => _serde::__private::Ok(__Field::__field23),
940                        24i8 => _serde::__private::Ok(__Field::__field24),
941                        25i8 => _serde::__private::Ok(__Field::__field25),
942                        26i8 => _serde::__private::Ok(__Field::__field26),
943                        27i8 => _serde::__private::Ok(__Field::__field27),
944                        28i8 => _serde::__private::Ok(__Field::__field28),
945                        29i8 => _serde::__private::Ok(__Field::__field29),
946                        30i8 => _serde::__private::Ok(__Field::__field30),
947                        31i8 => _serde::__private::Ok(__Field::__field31),
948                        32i8 => _serde::__private::Ok(__Field::__field32),
949                        33i8 => _serde::__private::Ok(__Field::__field33),
950                        34i8 => _serde::__private::Ok(__Field::__field34),
951                        35i8 => _serde::__private::Ok(__Field::__field35),
952                        36i8 => _serde::__private::Ok(__Field::__field36),
953                        37i8 => _serde::__private::Ok(__Field::__field37),
954                        38i8 => _serde::__private::Ok(__Field::__field38),
955                        39i8 => _serde::__private::Ok(__Field::__field39),
956                        40i8 => _serde::__private::Ok(__Field::__field40),
957                        41i8 => _serde::__private::Ok(__Field::__field41),
958                        42i8 => _serde::__private::Ok(__Field::__field42),
959                        43i8 => _serde::__private::Ok(__Field::__field43),
960                        _ => {
961                            _serde::__private::Err(
962                                _serde::de::Error::invalid_value(
963                                    _serde::de::Unexpected::Int8(__value),
964                                    &"value(i8) of variant is one of 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43",
965                                ),
966                            )
967                        }
968                    }
969                }
970                fn visit_stringptr<__E>(
971                    self,
972                    __value: StringPtr<'de>,
973                ) -> _serde::__private::Result<Self::Value, __E>
974                where
975                    __E: _serde::de::Error,
976                {
977                    if let Some(__value) = __value.into_inner() {
978                        match __value.as_ref() {
979                            v if v == "0" || v.eq_ignore_ascii_case("OP_NOP") => {
980                                _serde::__private::Ok(__Field::__field0)
981                            }
982                            v if v == "1" || v.eq_ignore_ascii_case("OP_RAND01") => {
983                                _serde::__private::Ok(__Field::__field1)
984                            }
985                            v if v == "2" || v.eq_ignore_ascii_case("OP_LOGICAL_NOT") => {
986                                _serde::__private::Ok(__Field::__field2)
987                            }
988                            v if v == "3" || v.eq_ignore_ascii_case("OP_UNARY_MINUS") => {
989                                _serde::__private::Ok(__Field::__field3)
990                            }
991                            v if v == "4" || v.eq_ignore_ascii_case("OP_UNARY_PLUS") => {
992                                _serde::__private::Ok(__Field::__field4)
993                            }
994                            v if v == "5" || v.eq_ignore_ascii_case("OP_SIN") => {
995                                _serde::__private::Ok(__Field::__field5)
996                            }
997                            v if v == "6" || v.eq_ignore_ascii_case("OP_COS") => {
998                                _serde::__private::Ok(__Field::__field6)
999                            }
1000                            v if v == "7" || v.eq_ignore_ascii_case("OP_ASIN") => {
1001                                _serde::__private::Ok(__Field::__field7)
1002                            }
1003                            v if v == "8" || v.eq_ignore_ascii_case("OP_ACOS") => {
1004                                _serde::__private::Ok(__Field::__field8)
1005                            }
1006                            v if v == "9" || v.eq_ignore_ascii_case("OP_SQRT") => {
1007                                _serde::__private::Ok(__Field::__field9)
1008                            }
1009                            v if v == "10" || v.eq_ignore_ascii_case("OP_FABS") => {
1010                                _serde::__private::Ok(__Field::__field10)
1011                            }
1012                            v if v == "11" || v.eq_ignore_ascii_case("OP_CEIL") => {
1013                                _serde::__private::Ok(__Field::__field11)
1014                            }
1015                            v if v == "12" || v.eq_ignore_ascii_case("OP_FLOOR") => {
1016                                _serde::__private::Ok(__Field::__field12)
1017                            }
1018                            v if v == "13" || v.eq_ignore_ascii_case("OP_SQRTINV") => {
1019                                _serde::__private::Ok(__Field::__field13)
1020                            }
1021                            v if v == "14" || v.eq_ignore_ascii_case("OP_MUL") => {
1022                                _serde::__private::Ok(__Field::__field14)
1023                            }
1024                            v if v == "15" || v.eq_ignore_ascii_case("OP_DIV") => {
1025                                _serde::__private::Ok(__Field::__field15)
1026                            }
1027                            v if v == "16" || v.eq_ignore_ascii_case("OP_ADD") => {
1028                                _serde::__private::Ok(__Field::__field16)
1029                            }
1030                            v if v == "17" || v.eq_ignore_ascii_case("OP_SUB") => {
1031                                _serde::__private::Ok(__Field::__field17)
1032                            }
1033                            v if v == "18" || v.eq_ignore_ascii_case("OP_LOGICAL_OR") => {
1034                                _serde::__private::Ok(__Field::__field18)
1035                            }
1036                            v if v == "19"
1037                                || v.eq_ignore_ascii_case("OP_LOGICAL_AND") => {
1038                                _serde::__private::Ok(__Field::__field19)
1039                            }
1040                            v if v == "20" || v.eq_ignore_ascii_case("OP_EQ") => {
1041                                _serde::__private::Ok(__Field::__field20)
1042                            }
1043                            v if v == "21" || v.eq_ignore_ascii_case("OP_NEQ") => {
1044                                _serde::__private::Ok(__Field::__field21)
1045                            }
1046                            v if v == "22" || v.eq_ignore_ascii_case("OP_LT") => {
1047                                _serde::__private::Ok(__Field::__field22)
1048                            }
1049                            v if v == "23" || v.eq_ignore_ascii_case("OP_GT") => {
1050                                _serde::__private::Ok(__Field::__field23)
1051                            }
1052                            v if v == "24" || v.eq_ignore_ascii_case("OP_LEQ") => {
1053                                _serde::__private::Ok(__Field::__field24)
1054                            }
1055                            v if v == "25" || v.eq_ignore_ascii_case("OP_GEQ") => {
1056                                _serde::__private::Ok(__Field::__field25)
1057                            }
1058                            v if v == "26" || v.eq_ignore_ascii_case("OP_POW") => {
1059                                _serde::__private::Ok(__Field::__field26)
1060                            }
1061                            v if v == "27" || v.eq_ignore_ascii_case("OP_MAX2") => {
1062                                _serde::__private::Ok(__Field::__field27)
1063                            }
1064                            v if v == "28" || v.eq_ignore_ascii_case("OP_MIN2") => {
1065                                _serde::__private::Ok(__Field::__field28)
1066                            }
1067                            v if v == "29" || v.eq_ignore_ascii_case("OP_RANDRANGE") => {
1068                                _serde::__private::Ok(__Field::__field29)
1069                            }
1070                            v if v == "30"
1071                                || v.eq_ignore_ascii_case("OP_ATAN2APPROX") => {
1072                                _serde::__private::Ok(__Field::__field30)
1073                            }
1074                            v if v == "31" || v.eq_ignore_ascii_case("OP_CLAMP") => {
1075                                _serde::__private::Ok(__Field::__field31)
1076                            }
1077                            v if v == "32" || v.eq_ignore_ascii_case("OP_MOD") => {
1078                                _serde::__private::Ok(__Field::__field32)
1079                            }
1080                            v if v == "33" || v.eq_ignore_ascii_case("OP_DEG2RAD") => {
1081                                _serde::__private::Ok(__Field::__field33)
1082                            }
1083                            v if v == "34" || v.eq_ignore_ascii_case("OP_RAD2DEG") => {
1084                                _serde::__private::Ok(__Field::__field34)
1085                            }
1086                            v if v == "35" || v.eq_ignore_ascii_case("OP_COSD") => {
1087                                _serde::__private::Ok(__Field::__field35)
1088                            }
1089                            v if v == "36" || v.eq_ignore_ascii_case("OP_SIND") => {
1090                                _serde::__private::Ok(__Field::__field36)
1091                            }
1092                            v if v == "37" || v.eq_ignore_ascii_case("OP_ACOSD") => {
1093                                _serde::__private::Ok(__Field::__field37)
1094                            }
1095                            v if v == "38" || v.eq_ignore_ascii_case("OP_ASIND") => {
1096                                _serde::__private::Ok(__Field::__field38)
1097                            }
1098                            v if v == "39"
1099                                || v.eq_ignore_ascii_case("OP_ATAN2APPROXD") => {
1100                                _serde::__private::Ok(__Field::__field39)
1101                            }
1102                            v if v == "40" || v.eq_ignore_ascii_case("OP_SIGN") => {
1103                                _serde::__private::Ok(__Field::__field40)
1104                            }
1105                            v if v == "41" || v.eq_ignore_ascii_case("OP_LERP") => {
1106                                _serde::__private::Ok(__Field::__field41)
1107                            }
1108                            v if v == "42" || v.eq_ignore_ascii_case("OP_CLERP") => {
1109                                _serde::__private::Ok(__Field::__field42)
1110                            }
1111                            v if v == "43" || v.eq_ignore_ascii_case("OP_COND") => {
1112                                _serde::__private::Ok(__Field::__field43)
1113                            }
1114                            _ => {
1115                                _serde::__private::Err(
1116                                    _serde::de::Error::unknown_variant(&__value, VARIANTS),
1117                                )
1118                            }
1119                        }
1120                    } else {
1121                        _serde::__private::Err(
1122                            _serde::de::Error::unknown_variant("None", VARIANTS),
1123                        )
1124                    }
1125                }
1126            }
1127            impl<'de> _serde::Deserialize<'de> for __Field {
1128                #[inline]
1129                fn deserialize<__D>(
1130                    __deserializer: __D,
1131                ) -> _serde::__private::Result<Self, __D::Error>
1132                where
1133                    __D: _serde::Deserializer<'de>,
1134                {
1135                    _serde::Deserializer::deserialize_identifier(
1136                        __deserializer,
1137                        _serde::de::ReadEnumSize::Int8,
1138                        __FieldVisitor,
1139                    )
1140                }
1141            }
1142            #[doc(hidden)]
1143            struct __Visitor<'de> {
1144                marker: _serde::__private::PhantomData<Operator>,
1145                lifetime: _serde::__private::PhantomData<&'de ()>,
1146            }
1147            impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
1148                type Value = Operator;
1149                fn expecting(
1150                    &self,
1151                    __formatter: &mut _serde::__private::Formatter,
1152                ) -> _serde::__private::fmt::Result {
1153                    _serde::__private::Formatter::write_str(__formatter, "enum Operator")
1154                }
1155                fn visit_enum<__A>(
1156                    self,
1157                    __data: __A,
1158                ) -> _serde::__private::Result<Self::Value, __A::Error>
1159                where
1160                    __A: _serde::de::EnumAccess<'de>,
1161                {
1162                    match _serde::de::EnumAccess::variant(__data)? {
1163                        (__Field::__field0, __variant) => {
1164                            _serde::de::VariantAccess::unit_variant(__variant)?;
1165                            _serde::__private::Ok(Operator::OP_NOP)
1166                        }
1167                        (__Field::__field1, __variant) => {
1168                            _serde::de::VariantAccess::unit_variant(__variant)?;
1169                            _serde::__private::Ok(Operator::OP_RAND01)
1170                        }
1171                        (__Field::__field2, __variant) => {
1172                            _serde::de::VariantAccess::unit_variant(__variant)?;
1173                            _serde::__private::Ok(Operator::OP_LOGICAL_NOT)
1174                        }
1175                        (__Field::__field3, __variant) => {
1176                            _serde::de::VariantAccess::unit_variant(__variant)?;
1177                            _serde::__private::Ok(Operator::OP_UNARY_MINUS)
1178                        }
1179                        (__Field::__field4, __variant) => {
1180                            _serde::de::VariantAccess::unit_variant(__variant)?;
1181                            _serde::__private::Ok(Operator::OP_UNARY_PLUS)
1182                        }
1183                        (__Field::__field5, __variant) => {
1184                            _serde::de::VariantAccess::unit_variant(__variant)?;
1185                            _serde::__private::Ok(Operator::OP_SIN)
1186                        }
1187                        (__Field::__field6, __variant) => {
1188                            _serde::de::VariantAccess::unit_variant(__variant)?;
1189                            _serde::__private::Ok(Operator::OP_COS)
1190                        }
1191                        (__Field::__field7, __variant) => {
1192                            _serde::de::VariantAccess::unit_variant(__variant)?;
1193                            _serde::__private::Ok(Operator::OP_ASIN)
1194                        }
1195                        (__Field::__field8, __variant) => {
1196                            _serde::de::VariantAccess::unit_variant(__variant)?;
1197                            _serde::__private::Ok(Operator::OP_ACOS)
1198                        }
1199                        (__Field::__field9, __variant) => {
1200                            _serde::de::VariantAccess::unit_variant(__variant)?;
1201                            _serde::__private::Ok(Operator::OP_SQRT)
1202                        }
1203                        (__Field::__field10, __variant) => {
1204                            _serde::de::VariantAccess::unit_variant(__variant)?;
1205                            _serde::__private::Ok(Operator::OP_FABS)
1206                        }
1207                        (__Field::__field11, __variant) => {
1208                            _serde::de::VariantAccess::unit_variant(__variant)?;
1209                            _serde::__private::Ok(Operator::OP_CEIL)
1210                        }
1211                        (__Field::__field12, __variant) => {
1212                            _serde::de::VariantAccess::unit_variant(__variant)?;
1213                            _serde::__private::Ok(Operator::OP_FLOOR)
1214                        }
1215                        (__Field::__field13, __variant) => {
1216                            _serde::de::VariantAccess::unit_variant(__variant)?;
1217                            _serde::__private::Ok(Operator::OP_SQRTINV)
1218                        }
1219                        (__Field::__field14, __variant) => {
1220                            _serde::de::VariantAccess::unit_variant(__variant)?;
1221                            _serde::__private::Ok(Operator::OP_MUL)
1222                        }
1223                        (__Field::__field15, __variant) => {
1224                            _serde::de::VariantAccess::unit_variant(__variant)?;
1225                            _serde::__private::Ok(Operator::OP_DIV)
1226                        }
1227                        (__Field::__field16, __variant) => {
1228                            _serde::de::VariantAccess::unit_variant(__variant)?;
1229                            _serde::__private::Ok(Operator::OP_ADD)
1230                        }
1231                        (__Field::__field17, __variant) => {
1232                            _serde::de::VariantAccess::unit_variant(__variant)?;
1233                            _serde::__private::Ok(Operator::OP_SUB)
1234                        }
1235                        (__Field::__field18, __variant) => {
1236                            _serde::de::VariantAccess::unit_variant(__variant)?;
1237                            _serde::__private::Ok(Operator::OP_LOGICAL_OR)
1238                        }
1239                        (__Field::__field19, __variant) => {
1240                            _serde::de::VariantAccess::unit_variant(__variant)?;
1241                            _serde::__private::Ok(Operator::OP_LOGICAL_AND)
1242                        }
1243                        (__Field::__field20, __variant) => {
1244                            _serde::de::VariantAccess::unit_variant(__variant)?;
1245                            _serde::__private::Ok(Operator::OP_EQ)
1246                        }
1247                        (__Field::__field21, __variant) => {
1248                            _serde::de::VariantAccess::unit_variant(__variant)?;
1249                            _serde::__private::Ok(Operator::OP_NEQ)
1250                        }
1251                        (__Field::__field22, __variant) => {
1252                            _serde::de::VariantAccess::unit_variant(__variant)?;
1253                            _serde::__private::Ok(Operator::OP_LT)
1254                        }
1255                        (__Field::__field23, __variant) => {
1256                            _serde::de::VariantAccess::unit_variant(__variant)?;
1257                            _serde::__private::Ok(Operator::OP_GT)
1258                        }
1259                        (__Field::__field24, __variant) => {
1260                            _serde::de::VariantAccess::unit_variant(__variant)?;
1261                            _serde::__private::Ok(Operator::OP_LEQ)
1262                        }
1263                        (__Field::__field25, __variant) => {
1264                            _serde::de::VariantAccess::unit_variant(__variant)?;
1265                            _serde::__private::Ok(Operator::OP_GEQ)
1266                        }
1267                        (__Field::__field26, __variant) => {
1268                            _serde::de::VariantAccess::unit_variant(__variant)?;
1269                            _serde::__private::Ok(Operator::OP_POW)
1270                        }
1271                        (__Field::__field27, __variant) => {
1272                            _serde::de::VariantAccess::unit_variant(__variant)?;
1273                            _serde::__private::Ok(Operator::OP_MAX2)
1274                        }
1275                        (__Field::__field28, __variant) => {
1276                            _serde::de::VariantAccess::unit_variant(__variant)?;
1277                            _serde::__private::Ok(Operator::OP_MIN2)
1278                        }
1279                        (__Field::__field29, __variant) => {
1280                            _serde::de::VariantAccess::unit_variant(__variant)?;
1281                            _serde::__private::Ok(Operator::OP_RANDRANGE)
1282                        }
1283                        (__Field::__field30, __variant) => {
1284                            _serde::de::VariantAccess::unit_variant(__variant)?;
1285                            _serde::__private::Ok(Operator::OP_ATAN2APPROX)
1286                        }
1287                        (__Field::__field31, __variant) => {
1288                            _serde::de::VariantAccess::unit_variant(__variant)?;
1289                            _serde::__private::Ok(Operator::OP_CLAMP)
1290                        }
1291                        (__Field::__field32, __variant) => {
1292                            _serde::de::VariantAccess::unit_variant(__variant)?;
1293                            _serde::__private::Ok(Operator::OP_MOD)
1294                        }
1295                        (__Field::__field33, __variant) => {
1296                            _serde::de::VariantAccess::unit_variant(__variant)?;
1297                            _serde::__private::Ok(Operator::OP_DEG2RAD)
1298                        }
1299                        (__Field::__field34, __variant) => {
1300                            _serde::de::VariantAccess::unit_variant(__variant)?;
1301                            _serde::__private::Ok(Operator::OP_RAD2DEG)
1302                        }
1303                        (__Field::__field35, __variant) => {
1304                            _serde::de::VariantAccess::unit_variant(__variant)?;
1305                            _serde::__private::Ok(Operator::OP_COSD)
1306                        }
1307                        (__Field::__field36, __variant) => {
1308                            _serde::de::VariantAccess::unit_variant(__variant)?;
1309                            _serde::__private::Ok(Operator::OP_SIND)
1310                        }
1311                        (__Field::__field37, __variant) => {
1312                            _serde::de::VariantAccess::unit_variant(__variant)?;
1313                            _serde::__private::Ok(Operator::OP_ACOSD)
1314                        }
1315                        (__Field::__field38, __variant) => {
1316                            _serde::de::VariantAccess::unit_variant(__variant)?;
1317                            _serde::__private::Ok(Operator::OP_ASIND)
1318                        }
1319                        (__Field::__field39, __variant) => {
1320                            _serde::de::VariantAccess::unit_variant(__variant)?;
1321                            _serde::__private::Ok(Operator::OP_ATAN2APPROXD)
1322                        }
1323                        (__Field::__field40, __variant) => {
1324                            _serde::de::VariantAccess::unit_variant(__variant)?;
1325                            _serde::__private::Ok(Operator::OP_SIGN)
1326                        }
1327                        (__Field::__field41, __variant) => {
1328                            _serde::de::VariantAccess::unit_variant(__variant)?;
1329                            _serde::__private::Ok(Operator::OP_LERP)
1330                        }
1331                        (__Field::__field42, __variant) => {
1332                            _serde::de::VariantAccess::unit_variant(__variant)?;
1333                            _serde::__private::Ok(Operator::OP_CLERP)
1334                        }
1335                        (__Field::__field43, __variant) => {
1336                            _serde::de::VariantAccess::unit_variant(__variant)?;
1337                            _serde::__private::Ok(Operator::OP_COND)
1338                        }
1339                    }
1340                }
1341            }
1342            #[doc(hidden)]
1343            const VARIANTS: &'static [&'static str] = &[
1344                "OP_NOP",
1345                "OP_RAND01",
1346                "OP_LOGICAL_NOT",
1347                "OP_UNARY_MINUS",
1348                "OP_UNARY_PLUS",
1349                "OP_SIN",
1350                "OP_COS",
1351                "OP_ASIN",
1352                "OP_ACOS",
1353                "OP_SQRT",
1354                "OP_FABS",
1355                "OP_CEIL",
1356                "OP_FLOOR",
1357                "OP_SQRTINV",
1358                "OP_MUL",
1359                "OP_DIV",
1360                "OP_ADD",
1361                "OP_SUB",
1362                "OP_LOGICAL_OR",
1363                "OP_LOGICAL_AND",
1364                "OP_EQ",
1365                "OP_NEQ",
1366                "OP_LT",
1367                "OP_GT",
1368                "OP_LEQ",
1369                "OP_GEQ",
1370                "OP_POW",
1371                "OP_MAX2",
1372                "OP_MIN2",
1373                "OP_RANDRANGE",
1374                "OP_ATAN2APPROX",
1375                "OP_CLAMP",
1376                "OP_MOD",
1377                "OP_DEG2RAD",
1378                "OP_RAD2DEG",
1379                "OP_COSD",
1380                "OP_SIND",
1381                "OP_ACOSD",
1382                "OP_ASIND",
1383                "OP_ATAN2APPROXD",
1384                "OP_SIGN",
1385                "OP_LERP",
1386                "OP_CLERP",
1387                "OP_COND",
1388            ];
1389            _serde::Deserializer::deserialize_enum(
1390                __deserializer,
1391                "Operator",
1392                VARIANTS,
1393                __Visitor {
1394                    marker: _serde::__private::PhantomData::<Operator>,
1395                    lifetime: _serde::__private::PhantomData,
1396                },
1397            )
1398        }
1399    }
1400};