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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

pub mod texture_transform;

use serde::de::Error;
use serde::{Deserialize, Deserializer, Serialize};
use serde_repr::{Deserialize_repr, Serialize_repr};
use std::borrow::Cow;
pub use texture_transform::TextureTransform;

#[derive(Debug, Serialize, Deserialize, Copy, Clone, Default)]
#[serde(from = "Vec2OrSingle<f32>")]
pub struct Vec2(pub [f32; 2]);

pub(crate) fn deserialize_bare_vec2<'de, D: Deserializer<'de>>(
    deserializer: D,
) -> Result<Vec2, D::Error> {
    let str = Cow::<str>::deserialize(deserializer)?;
    let (x, y) = str
        .trim()
        .split_once(' ')
        .ok_or_else(|| D::Error::custom("doesn't look like a vec2"))?;
    let x = x.trim().parse().map_err(D::Error::custom)?;
    let y = y.trim().parse().map_err(D::Error::custom)?;

    Ok(Vec2([x, y]))
}

impl From<Vec2OrSingle<f32>> for Vec2 {
    fn from(value: Vec2OrSingle<f32>) -> Self {
        match value {
            Vec2OrSingle::Vec2(vec) => Vec2(vec),
            Vec2OrSingle::Single(val) => Vec2([val; 2]),
        }
    }
}

#[derive(Debug, Serialize, Deserialize, Copy, Clone, Default)]
#[serde(from = "Vec3OrSingle<f32>")]
pub struct Vec3(pub [f32; 3]);

impl From<Vec3OrSingle<f32>> for Vec3 {
    fn from(value: Vec3OrSingle<f32>) -> Self {
        match value {
            Vec3OrSingle::Vec3(vec) => Vec3(vec),
            Vec3OrSingle::Single(val) => Vec3([val; 3]),
        }
    }
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
enum Vec3OrSingle<T> {
    Vec3([T; 3]),
    Single(T),
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(untagged)]
enum Vec2OrSingle<T> {
    Vec2([T; 2]),
    Single(T),
}

pub(crate) fn default_scale3() -> Vec3 {
    Vec3([1.0; 3])
}

#[allow(dead_code)]
pub(crate) fn default_scale2() -> Vec2 {
    Vec2([1.0; 2])
}

pub(crate) fn default_scale() -> f32 {
    1.0
}

pub(crate) fn default_detail_scale() -> Vec2 {
    Vec2([4.0; 2])
}

#[derive(Serialize_repr, Deserialize_repr, PartialEq, Debug, Copy, Clone, Default)]
#[repr(u8)]
pub enum BlendMode {
    DecalModulate = 0,
    #[default]
    Additive = 1,
    TranslucentOverlay = 2,
    BlendFactorOverlay = 3,
    TranslucentBase = 4,
    UnlitAdditive = 5,
    UnlitAdditiveThreshold = 6,
    TwoPatternModulate = 7,
    Multiply = 8,
    BaseMaskAlpha = 9,
    SelfShadowedBumpMap = 10,
    SelfShadowedBumpAlbedo = 11,
}