scenix-texture 1.3.0

CPU-side texture data, samplers, atlases, and mipmap helpers for scenix.
Documentation 
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

/// Texture filtering mode.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum FilterMode {
    /// Nearest-neighbor sampling.
    Nearest,
    /// Linear interpolation.
    #[default]
    Linear,
}

/// Texture coordinate addressing mode.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum AddressMode {
    /// Repeat outside `[0, 1]`.
    Repeat,
    /// Mirror every repeated interval.
    MirrorRepeat,
    /// Clamp coordinates to the edge texels.
    #[default]
    ClampToEdge,
}

/// Optional depth-compare function for shadow/depth sampling.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum CompareFunction {
    /// Passes when the sampled value is less than the reference.
    Less,
    /// Passes when the sampled value is less than or equal to the reference.
    LessEqual,
    /// Passes when the sampled value is greater than the reference.
    Greater,
    /// Passes when the sampled value is greater than or equal to the reference.
    GreaterEqual,
    /// Passes when the sampled value equals the reference.
    Equal,
    /// Passes when the sampled value differs from the reference.
    NotEqual,
    /// Always passes.
    Always,
    /// Never passes.
    Never,
}

/// CPU-side sampler configuration.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Sampler {
    /// Magnification filter.
    pub mag_filter: FilterMode,
    /// Minification filter.
    pub min_filter: FilterMode,
    /// Mipmap filter.
    pub mip_filter: FilterMode,
    /// Addressing for U coordinates.
    pub address_u: AddressMode,
    /// Addressing for V coordinates.
    pub address_v: AddressMode,
    /// Addressing for W coordinates.
    pub address_w: AddressMode,
    /// Anisotropy level clamped to `1..=16`.
    pub anisotropy: u8,
    /// Optional depth compare function.
    pub compare: Option<CompareFunction>,
}

impl Sampler {
    /// Creates a default linear clamp sampler.
    #[inline]
    pub const fn new() -> Self {
        Self {
            mag_filter: FilterMode::Linear,
            min_filter: FilterMode::Linear,
            mip_filter: FilterMode::Linear,
            address_u: AddressMode::ClampToEdge,
            address_v: AddressMode::ClampToEdge,
            address_w: AddressMode::ClampToEdge,
            anisotropy: 1,
            compare: None,
        }
    }

    /// Returns this sampler with filter modes set.
    #[inline]
    pub const fn filters(
        mut self,
        mag_filter: FilterMode,
        min_filter: FilterMode,
        mip_filter: FilterMode,
    ) -> Self {
        self.mag_filter = mag_filter;
        self.min_filter = min_filter;
        self.mip_filter = mip_filter;
        self
    }

    /// Returns this sampler with address modes set.
    #[inline]
    pub const fn address_modes(
        mut self,
        address_u: AddressMode,
        address_v: AddressMode,
        address_w: AddressMode,
    ) -> Self {
        self.address_u = address_u;
        self.address_v = address_v;
        self.address_w = address_w;
        self
    }

    /// Returns this sampler with anisotropy clamped to `1..=16`.
    #[inline]
    pub const fn anisotropy(mut self, anisotropy: u8) -> Self {
        self.anisotropy = if anisotropy < 1 {
            1
        } else if anisotropy > 16 {
            16
        } else {
            anisotropy
        };
        self
    }

    /// Returns this sampler with a compare function.
    #[inline]
    pub const fn compare(mut self, compare: Option<CompareFunction>) -> Self {
        self.compare = compare;
        self
    }
}

impl Default for Sampler {
    #[inline]
    fn default() -> Self {
        Self::new()
    }
}