havok_classes/generated/
hkbSetWordVariableCommand_.rs

1use super::class_requires::*;
2use super::*;
3/// # C++ Info
4/// - name: `hkbSetWordVariableCommand`
5/// - version: `0`
6/// - signature: `0xf3ae5fca`
7/// - size: ` 64`(x86)/` 64`(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 hkbSetWordVariableCommand {
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: `quadValue`(ctype: `hkVector4`)
32    /// - offset: ` 16`(x86)/` 16`(x86_64)
33    /// - type_size: ` 16`(x86)/` 16`(x86_64)
34    #[cfg_attr(feature = "json_schema", schemars(rename = "quadValue"))]
35    #[cfg_attr(feature = "serde", serde(rename = "quadValue"))]
36    pub m_quadValue: Vector4,
37    /// # C++ Info
38    /// - name: `characterId`(ctype: `hkUint64`)
39    /// - offset: ` 32`(x86)/` 32`(x86_64)
40    /// - type_size: `  8`(x86)/`  8`(x86_64)
41    #[cfg_attr(feature = "json_schema", schemars(rename = "characterId"))]
42    #[cfg_attr(feature = "serde", serde(rename = "characterId"))]
43    pub m_characterId: u64,
44    /// # C++ Info
45    /// - name: `variableId`(ctype: `hkInt32`)
46    /// - offset: ` 40`(x86)/` 40`(x86_64)
47    /// - type_size: `  4`(x86)/`  4`(x86_64)
48    #[cfg_attr(feature = "json_schema", schemars(rename = "variableId"))]
49    #[cfg_attr(feature = "serde", serde(rename = "variableId"))]
50    pub m_variableId: i32,
51    /// # C++ Info
52    /// - name: `value`(ctype: `struct hkbVariableValue`)
53    /// - offset: ` 44`(x86)/` 44`(x86_64)
54    /// - type_size: `  4`(x86)/`  4`(x86_64)
55    #[cfg_attr(feature = "json_schema", schemars(rename = "value"))]
56    #[cfg_attr(feature = "serde", serde(rename = "value"))]
57    pub m_value: hkbVariableValue,
58    /// # C++ Info
59    /// - name: `type`(ctype: `enum VariableType`)
60    /// - offset: ` 48`(x86)/` 48`(x86_64)
61    /// - type_size: `  1`(x86)/`  1`(x86_64)
62    #[cfg_attr(feature = "json_schema", schemars(rename = "type"))]
63    #[cfg_attr(feature = "serde", serde(rename = "type"))]
64    pub m_type: VariableType,
65    /// # C++ Info
66    /// - name: `global`(ctype: `hkBool`)
67    /// - offset: ` 49`(x86)/` 49`(x86_64)
68    /// - type_size: `  1`(x86)/`  1`(x86_64)
69    #[cfg_attr(feature = "json_schema", schemars(rename = "global"))]
70    #[cfg_attr(feature = "serde", serde(rename = "global"))]
71    pub m_global: bool,
72}
73const _: () = {
74    use havok_serde as _serde;
75    impl _serde::HavokClass for hkbSetWordVariableCommand {
76        #[inline]
77        fn name(&self) -> &'static str {
78            "hkbSetWordVariableCommand"
79        }
80        #[inline]
81        fn signature(&self) -> _serde::__private::Signature {
82            _serde::__private::Signature::new(0xf3ae5fca)
83        }
84        #[allow(clippy::let_and_return, clippy::vec_init_then_push)]
85        fn deps_indexes(&self) -> Vec<usize> {
86            let mut v = Vec::new();
87            v.extend(self.m_value.deps_indexes());
88            v
89        }
90    }
91    impl _serde::Serialize for hkbSetWordVariableCommand {
92        fn serialize<S>(&self, __serializer: S) -> Result<S::Ok, S::Error>
93        where
94            S: _serde::ser::Serializer,
95        {
96            let class_meta = self
97                .__ptr
98                .map(|name| (name, _serde::__private::Signature::new(0xf3ae5fca)));
99            let mut serializer = __serializer
100                .serialize_struct(
101                    "hkbSetWordVariableCommand",
102                    class_meta,
103                    (64u64, 64u64),
104                )?;
105            serializer.pad_field([0u8; 4usize].as_slice(), [0u8; 8usize].as_slice())?;
106            serializer.skip_field("memSizeAndFlags", &self.parent.m_memSizeAndFlags)?;
107            serializer.skip_field("referenceCount", &self.parent.m_referenceCount)?;
108            serializer.pad_field([0u8; 0usize].as_slice(), [0u8; 4usize].as_slice())?;
109            serializer.pad_field([0u8; 8usize].as_slice(), [0u8; 0usize].as_slice())?;
110            serializer.serialize_field("quadValue", &self.m_quadValue)?;
111            serializer.serialize_field("characterId", &self.m_characterId)?;
112            serializer.serialize_field("variableId", &self.m_variableId)?;
113            serializer.serialize_field("value", &self.m_value)?;
114            serializer.serialize_field("type", &self.m_type)?;
115            serializer.serialize_field("global", &self.m_global)?;
116            serializer.pad_field([0u8; 14usize].as_slice(), [0u8; 14usize].as_slice())?;
117            serializer.end()
118        }
119    }
120};
121#[doc(hidden)]
122#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
123const _: () = {
124    use havok_serde as _serde;
125    #[automatically_derived]
126    impl<'de> _serde::Deserialize<'de> for hkbSetWordVariableCommand {
127        fn deserialize<__D>(deserializer: __D) -> core::result::Result<Self, __D::Error>
128        where
129            __D: _serde::Deserializer<'de>,
130        {
131            #[allow(non_camel_case_types)]
132            enum __Field {
133                m_quadValue,
134                m_characterId,
135                m_variableId,
136                m_value,
137                m_type,
138                m_global,
139                __ignore,
140            }
141            struct __FieldVisitor;
142            impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
143                type Value = __Field;
144                fn expecting(
145                    &self,
146                    __formatter: &mut core::fmt::Formatter,
147                ) -> core::fmt::Result {
148                    core::fmt::Formatter::write_str(__formatter, "field identifier")
149                }
150                /// Intended for use in XML.
151                #[allow(clippy::match_single_binding)]
152                #[allow(clippy::reversed_empty_ranges)]
153                #[allow(clippy::single_match)]
154                fn visit_key<__E>(
155                    self,
156                    __value: &str,
157                ) -> core::result::Result<Self::Value, __E>
158                where
159                    __E: _serde::de::Error,
160                {
161                    match __value {
162                        "quadValue" => Ok(__Field::m_quadValue),
163                        "characterId" => Ok(__Field::m_characterId),
164                        "variableId" => Ok(__Field::m_variableId),
165                        "value" => Ok(__Field::m_value),
166                        "type" => Ok(__Field::m_type),
167                        "global" => Ok(__Field::m_global),
168                        _ => Ok(__Field::__ignore),
169                    }
170                }
171            }
172            impl<'de> _serde::Deserialize<'de> for __Field {
173                #[inline]
174                fn deserialize<__D>(
175                    __deserializer: __D,
176                ) -> core::result::Result<Self, __D::Error>
177                where
178                    __D: _serde::Deserializer<'de>,
179                {
180                    _serde::Deserializer::deserialize_key(__deserializer, __FieldVisitor)
181                }
182            }
183            struct __hkbSetWordVariableCommandVisitor<'de> {
184                marker: _serde::__private::PhantomData<hkbSetWordVariableCommand>,
185                lifetime: _serde::__private::PhantomData<&'de ()>,
186            }
187            #[allow(clippy::match_single_binding)]
188            #[allow(clippy::reversed_empty_ranges)]
189            #[allow(clippy::single_match)]
190            impl<'de> _serde::de::Visitor<'de>
191            for __hkbSetWordVariableCommandVisitor<'de> {
192                type Value = hkbSetWordVariableCommand;
193                fn expecting(
194                    &self,
195                    __formatter: &mut core::fmt::Formatter,
196                ) -> core::fmt::Result {
197                    core::fmt::Formatter::write_str(
198                        __formatter,
199                        "struct hkbSetWordVariableCommand",
200                    )
201                }
202                fn visit_struct_for_bytes<__A>(
203                    self,
204                    mut __map: __A,
205                ) -> _serde::__private::Result<Self::Value, __A::Error>
206                where
207                    __A: _serde::de::MapAccess<'de>,
208                {
209                    let __ptr = __A::class_ptr(&mut __map);
210                    let parent = __A::parent_value(&mut __map)?;
211                    let mut m_quadValue: _serde::__private::Option<Vector4> = _serde::__private::None;
212                    let mut m_characterId: _serde::__private::Option<u64> = _serde::__private::None;
213                    let mut m_variableId: _serde::__private::Option<i32> = _serde::__private::None;
214                    let mut m_value: _serde::__private::Option<hkbVariableValue> = _serde::__private::None;
215                    let mut m_type: _serde::__private::Option<VariableType> = _serde::__private::None;
216                    let mut m_global: _serde::__private::Option<bool> = _serde::__private::None;
217                    for i in 0..6usize {
218                        match i {
219                            0usize => {
220                                if _serde::__private::Option::is_some(&m_quadValue) {
221                                    return _serde::__private::Err(
222                                        <__A::Error as _serde::de::Error>::duplicate_field(
223                                            "quadValue",
224                                        ),
225                                    );
226                                }
227                                __A::pad(&mut __map, 8usize, 0usize)?;
228                                m_quadValue = _serde::__private::Some(
229                                    match __A::next_value::<Vector4>(&mut __map) {
230                                        _serde::__private::Ok(__val) => __val,
231                                        _serde::__private::Err(__err) => {
232                                            return _serde::__private::Err(__err);
233                                        }
234                                    },
235                                );
236                            }
237                            1usize => {
238                                if _serde::__private::Option::is_some(&m_characterId) {
239                                    return _serde::__private::Err(
240                                        <__A::Error as _serde::de::Error>::duplicate_field(
241                                            "characterId",
242                                        ),
243                                    );
244                                }
245                                m_characterId = _serde::__private::Some(
246                                    match __A::next_value::<u64>(&mut __map) {
247                                        _serde::__private::Ok(__val) => __val,
248                                        _serde::__private::Err(__err) => {
249                                            return _serde::__private::Err(__err);
250                                        }
251                                    },
252                                );
253                            }
254                            2usize => {
255                                if _serde::__private::Option::is_some(&m_variableId) {
256                                    return _serde::__private::Err(
257                                        <__A::Error as _serde::de::Error>::duplicate_field(
258                                            "variableId",
259                                        ),
260                                    );
261                                }
262                                m_variableId = _serde::__private::Some(
263                                    match __A::next_value::<i32>(&mut __map) {
264                                        _serde::__private::Ok(__val) => __val,
265                                        _serde::__private::Err(__err) => {
266                                            return _serde::__private::Err(__err);
267                                        }
268                                    },
269                                );
270                            }
271                            3usize => {
272                                if _serde::__private::Option::is_some(&m_value) {
273                                    return _serde::__private::Err(
274                                        <__A::Error as _serde::de::Error>::duplicate_field("value"),
275                                    );
276                                }
277                                m_value = _serde::__private::Some(
278                                    match __A::next_value::<hkbVariableValue>(&mut __map) {
279                                        _serde::__private::Ok(__val) => __val,
280                                        _serde::__private::Err(__err) => {
281                                            return _serde::__private::Err(__err);
282                                        }
283                                    },
284                                );
285                            }
286                            4usize => {
287                                if _serde::__private::Option::is_some(&m_type) {
288                                    return _serde::__private::Err(
289                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
290                                    );
291                                }
292                                m_type = _serde::__private::Some(
293                                    match __A::next_value::<VariableType>(&mut __map) {
294                                        _serde::__private::Ok(__val) => __val,
295                                        _serde::__private::Err(__err) => {
296                                            return _serde::__private::Err(__err);
297                                        }
298                                    },
299                                );
300                            }
301                            5usize => {
302                                if _serde::__private::Option::is_some(&m_global) {
303                                    return _serde::__private::Err(
304                                        <__A::Error as _serde::de::Error>::duplicate_field("global"),
305                                    );
306                                }
307                                m_global = _serde::__private::Some(
308                                    match __A::next_value::<bool>(&mut __map) {
309                                        _serde::__private::Ok(__val) => __val,
310                                        _serde::__private::Err(__err) => {
311                                            return _serde::__private::Err(__err);
312                                        }
313                                    },
314                                );
315                            }
316                            _ => {}
317                        }
318                    }
319                    __A::pad(&mut __map, 14usize, 14usize)?;
320                    let m_quadValue = match m_quadValue {
321                        _serde::__private::Some(__field) => __field,
322                        _serde::__private::None => {
323                            return _serde::__private::Err(
324                                <__A::Error as _serde::de::Error>::missing_field(
325                                    "quadValue",
326                                ),
327                            );
328                        }
329                    };
330                    let m_characterId = match m_characterId {
331                        _serde::__private::Some(__field) => __field,
332                        _serde::__private::None => {
333                            return _serde::__private::Err(
334                                <__A::Error as _serde::de::Error>::missing_field(
335                                    "characterId",
336                                ),
337                            );
338                        }
339                    };
340                    let m_variableId = match m_variableId {
341                        _serde::__private::Some(__field) => __field,
342                        _serde::__private::None => {
343                            return _serde::__private::Err(
344                                <__A::Error as _serde::de::Error>::missing_field(
345                                    "variableId",
346                                ),
347                            );
348                        }
349                    };
350                    let m_value = match m_value {
351                        _serde::__private::Some(__field) => __field,
352                        _serde::__private::None => {
353                            return _serde::__private::Err(
354                                <__A::Error as _serde::de::Error>::missing_field("value"),
355                            );
356                        }
357                    };
358                    let m_type = match m_type {
359                        _serde::__private::Some(__field) => __field,
360                        _serde::__private::None => {
361                            return _serde::__private::Err(
362                                <__A::Error as _serde::de::Error>::missing_field("type"),
363                            );
364                        }
365                    };
366                    let m_global = match m_global {
367                        _serde::__private::Some(__field) => __field,
368                        _serde::__private::None => {
369                            return _serde::__private::Err(
370                                <__A::Error as _serde::de::Error>::missing_field("global"),
371                            );
372                        }
373                    };
374                    _serde::__private::Ok(hkbSetWordVariableCommand {
375                        __ptr,
376                        parent,
377                        m_quadValue,
378                        m_characterId,
379                        m_variableId,
380                        m_value,
381                        m_type,
382                        m_global,
383                    })
384                }
385                #[allow(clippy::manual_unwrap_or_default)]
386                fn visit_struct<__A>(
387                    self,
388                    mut __map: __A,
389                ) -> _serde::__private::Result<Self::Value, __A::Error>
390                where
391                    __A: _serde::de::MapAccess<'de>,
392                {
393                    let mut m_quadValue: _serde::__private::Option<Vector4> = _serde::__private::None;
394                    let mut m_characterId: _serde::__private::Option<u64> = _serde::__private::None;
395                    let mut m_variableId: _serde::__private::Option<i32> = _serde::__private::None;
396                    let mut m_value: _serde::__private::Option<hkbVariableValue> = _serde::__private::None;
397                    let mut m_type: _serde::__private::Option<VariableType> = _serde::__private::None;
398                    let mut m_global: _serde::__private::Option<bool> = _serde::__private::None;
399                    while let _serde::__private::Some(__key) = {
400                        __A::next_key::<__Field>(&mut __map)?
401                    } {
402                        match __key {
403                            __Field::m_quadValue => {
404                                #[cfg(
405                                    any(feature = "strict", feature = "ignore_duplicates")
406                                )]
407                                if _serde::__private::Option::is_some(&m_quadValue) {
408                                    #[cfg(feature = "ignore_duplicates")]
409                                    {
410                                        __A::skip_value(&mut __map)?;
411                                        continue;
412                                    }
413                                    #[cfg(feature = "strict")]
414                                    return _serde::__private::Err(
415                                        <__A::Error as _serde::de::Error>::duplicate_field(
416                                            "quadValue",
417                                        ),
418                                    );
419                                }
420                                m_quadValue = _serde::__private::Some(
421                                    match __A::next_value::<Vector4>(&mut __map) {
422                                        _serde::__private::Ok(__val) => __val,
423                                        _serde::__private::Err(__err) => {
424                                            return _serde::__private::Err(__err);
425                                        }
426                                    },
427                                );
428                            }
429                            __Field::m_characterId => {
430                                #[cfg(
431                                    any(feature = "strict", feature = "ignore_duplicates")
432                                )]
433                                if _serde::__private::Option::is_some(&m_characterId) {
434                                    #[cfg(feature = "ignore_duplicates")]
435                                    {
436                                        __A::skip_value(&mut __map)?;
437                                        continue;
438                                    }
439                                    #[cfg(feature = "strict")]
440                                    return _serde::__private::Err(
441                                        <__A::Error as _serde::de::Error>::duplicate_field(
442                                            "characterId",
443                                        ),
444                                    );
445                                }
446                                m_characterId = _serde::__private::Some(
447                                    match __A::next_value::<u64>(&mut __map) {
448                                        _serde::__private::Ok(__val) => __val,
449                                        _serde::__private::Err(__err) => {
450                                            return _serde::__private::Err(__err);
451                                        }
452                                    },
453                                );
454                            }
455                            __Field::m_variableId => {
456                                #[cfg(
457                                    any(feature = "strict", feature = "ignore_duplicates")
458                                )]
459                                if _serde::__private::Option::is_some(&m_variableId) {
460                                    #[cfg(feature = "ignore_duplicates")]
461                                    {
462                                        __A::skip_value(&mut __map)?;
463                                        continue;
464                                    }
465                                    #[cfg(feature = "strict")]
466                                    return _serde::__private::Err(
467                                        <__A::Error as _serde::de::Error>::duplicate_field(
468                                            "variableId",
469                                        ),
470                                    );
471                                }
472                                m_variableId = _serde::__private::Some(
473                                    match __A::next_value::<i32>(&mut __map) {
474                                        _serde::__private::Ok(__val) => __val,
475                                        _serde::__private::Err(__err) => {
476                                            return _serde::__private::Err(__err);
477                                        }
478                                    },
479                                );
480                            }
481                            __Field::m_value => {
482                                #[cfg(
483                                    any(feature = "strict", feature = "ignore_duplicates")
484                                )]
485                                if _serde::__private::Option::is_some(&m_value) {
486                                    #[cfg(feature = "ignore_duplicates")]
487                                    {
488                                        __A::skip_value(&mut __map)?;
489                                        continue;
490                                    }
491                                    #[cfg(feature = "strict")]
492                                    return _serde::__private::Err(
493                                        <__A::Error as _serde::de::Error>::duplicate_field("value"),
494                                    );
495                                }
496                                m_value = _serde::__private::Some(
497                                    match __A::next_value::<hkbVariableValue>(&mut __map) {
498                                        _serde::__private::Ok(__val) => __val,
499                                        _serde::__private::Err(__err) => {
500                                            return _serde::__private::Err(__err);
501                                        }
502                                    },
503                                );
504                            }
505                            __Field::m_type => {
506                                #[cfg(
507                                    any(feature = "strict", feature = "ignore_duplicates")
508                                )]
509                                if _serde::__private::Option::is_some(&m_type) {
510                                    #[cfg(feature = "ignore_duplicates")]
511                                    {
512                                        __A::skip_value(&mut __map)?;
513                                        continue;
514                                    }
515                                    #[cfg(feature = "strict")]
516                                    return _serde::__private::Err(
517                                        <__A::Error as _serde::de::Error>::duplicate_field("type"),
518                                    );
519                                }
520                                m_type = _serde::__private::Some(
521                                    match __A::next_value::<VariableType>(&mut __map) {
522                                        _serde::__private::Ok(__val) => __val,
523                                        _serde::__private::Err(__err) => {
524                                            return _serde::__private::Err(__err);
525                                        }
526                                    },
527                                );
528                            }
529                            __Field::m_global => {
530                                #[cfg(
531                                    any(feature = "strict", feature = "ignore_duplicates")
532                                )]
533                                if _serde::__private::Option::is_some(&m_global) {
534                                    #[cfg(feature = "ignore_duplicates")]
535                                    {
536                                        __A::skip_value(&mut __map)?;
537                                        continue;
538                                    }
539                                    #[cfg(feature = "strict")]
540                                    return _serde::__private::Err(
541                                        <__A::Error as _serde::de::Error>::duplicate_field("global"),
542                                    );
543                                }
544                                m_global = _serde::__private::Some(
545                                    match __A::next_value::<bool>(&mut __map) {
546                                        _serde::__private::Ok(__val) => __val,
547                                        _serde::__private::Err(__err) => {
548                                            return _serde::__private::Err(__err);
549                                        }
550                                    },
551                                );
552                            }
553                            _ => __A::skip_value(&mut __map)?,
554                        }
555                    }
556                    let m_quadValue = match m_quadValue {
557                        _serde::__private::Some(__field) => __field,
558                        _serde::__private::None => {
559                            #[cfg(feature = "strict")]
560                            return _serde::__private::Err(
561                                <__A::Error as _serde::de::Error>::missing_field(
562                                    "quadValue",
563                                ),
564                            );
565                            #[cfg(not(feature = "strict"))] Default::default()
566                        }
567                    };
568                    let m_characterId = match m_characterId {
569                        _serde::__private::Some(__field) => __field,
570                        _serde::__private::None => {
571                            #[cfg(feature = "strict")]
572                            return _serde::__private::Err(
573                                <__A::Error as _serde::de::Error>::missing_field(
574                                    "characterId",
575                                ),
576                            );
577                            #[cfg(not(feature = "strict"))] Default::default()
578                        }
579                    };
580                    let m_variableId = match m_variableId {
581                        _serde::__private::Some(__field) => __field,
582                        _serde::__private::None => {
583                            #[cfg(feature = "strict")]
584                            return _serde::__private::Err(
585                                <__A::Error as _serde::de::Error>::missing_field(
586                                    "variableId",
587                                ),
588                            );
589                            #[cfg(not(feature = "strict"))] Default::default()
590                        }
591                    };
592                    let m_value = match m_value {
593                        _serde::__private::Some(__field) => __field,
594                        _serde::__private::None => {
595                            #[cfg(feature = "strict")]
596                            return _serde::__private::Err(
597                                <__A::Error as _serde::de::Error>::missing_field("value"),
598                            );
599                            #[cfg(not(feature = "strict"))] Default::default()
600                        }
601                    };
602                    let m_type = match m_type {
603                        _serde::__private::Some(__field) => __field,
604                        _serde::__private::None => {
605                            #[cfg(feature = "strict")]
606                            return _serde::__private::Err(
607                                <__A::Error as _serde::de::Error>::missing_field("type"),
608                            );
609                            #[cfg(not(feature = "strict"))] Default::default()
610                        }
611                    };
612                    let m_global = match m_global {
613                        _serde::__private::Some(__field) => __field,
614                        _serde::__private::None => {
615                            #[cfg(feature = "strict")]
616                            return _serde::__private::Err(
617                                <__A::Error as _serde::de::Error>::missing_field("global"),
618                            );
619                            #[cfg(not(feature = "strict"))] Default::default()
620                        }
621                    };
622                    let __ptr = None;
623                    let parent = hkBaseObject { __ptr };
624                    let parent = hkReferencedObject {
625                        __ptr,
626                        parent,
627                        ..Default::default()
628                    };
629                    let __ptr = __A::class_ptr(&mut __map);
630                    _serde::__private::Ok(hkbSetWordVariableCommand {
631                        __ptr,
632                        parent,
633                        m_quadValue,
634                        m_characterId,
635                        m_variableId,
636                        m_value,
637                        m_type,
638                        m_global,
639                    })
640                }
641            }
642            const FIELDS: &[&str] = &[
643                "quadValue",
644                "characterId",
645                "variableId",
646                "value",
647                "type",
648                "global",
649            ];
650            _serde::Deserializer::deserialize_struct(
651                deserializer,
652                "hkbSetWordVariableCommand",
653                FIELDS,
654                __hkbSetWordVariableCommandVisitor {
655                    marker: _serde::__private::PhantomData::<hkbSetWordVariableCommand>,
656                    lifetime: _serde::__private::PhantomData,
657                },
658            )
659        }
660    }
661};
havok_classes/generated/hkbSetWordVariableCommand_.rs

havok_classes/generated/
hkbSetWordVariableCommand_.rs
