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