Skip to main content

scenix_texture/
sampler.rs

1/// Texture filtering mode.
2#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
3#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4pub enum FilterMode {
5    /// Nearest-neighbor sampling.
6    Nearest,
7    /// Linear interpolation.
8    #[default]
9    Linear,
10}
11
12/// Texture coordinate addressing mode.
13#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
14#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
15pub enum AddressMode {
16    /// Repeat outside `[0, 1]`.
17    Repeat,
18    /// Mirror every repeated interval.
19    MirrorRepeat,
20    /// Clamp coordinates to the edge texels.
21    #[default]
22    ClampToEdge,
23}
24
25/// Optional depth-compare function for shadow/depth sampling.
26#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
27#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
28pub enum CompareFunction {
29    /// Passes when the sampled value is less than the reference.
30    Less,
31    /// Passes when the sampled value is less than or equal to the reference.
32    LessEqual,
33    /// Passes when the sampled value is greater than the reference.
34    Greater,
35    /// Passes when the sampled value is greater than or equal to the reference.
36    GreaterEqual,
37    /// Passes when the sampled value equals the reference.
38    Equal,
39    /// Passes when the sampled value differs from the reference.
40    NotEqual,
41    /// Always passes.
42    Always,
43    /// Never passes.
44    Never,
45}
46
47/// CPU-side sampler configuration.
48#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
49#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
50pub struct Sampler {
51    /// Magnification filter.
52    pub mag_filter: FilterMode,
53    /// Minification filter.
54    pub min_filter: FilterMode,
55    /// Mipmap filter.
56    pub mip_filter: FilterMode,
57    /// Addressing for U coordinates.
58    pub address_u: AddressMode,
59    /// Addressing for V coordinates.
60    pub address_v: AddressMode,
61    /// Addressing for W coordinates.
62    pub address_w: AddressMode,
63    /// Anisotropy level clamped to `1..=16`.
64    pub anisotropy: u8,
65    /// Optional depth compare function.
66    pub compare: Option<CompareFunction>,
67}
68
69impl Sampler {
70    /// Creates a default linear clamp sampler.
71    #[inline]
72    pub const fn new() -> Self {
73        Self {
74            mag_filter: FilterMode::Linear,
75            min_filter: FilterMode::Linear,
76            mip_filter: FilterMode::Linear,
77            address_u: AddressMode::ClampToEdge,
78            address_v: AddressMode::ClampToEdge,
79            address_w: AddressMode::ClampToEdge,
80            anisotropy: 1,
81            compare: None,
82        }
83    }
84
85    /// Returns this sampler with filter modes set.
86    #[inline]
87    pub const fn filters(
88        mut self,
89        mag_filter: FilterMode,
90        min_filter: FilterMode,
91        mip_filter: FilterMode,
92    ) -> Self {
93        self.mag_filter = mag_filter;
94        self.min_filter = min_filter;
95        self.mip_filter = mip_filter;
96        self
97    }
98
99    /// Returns this sampler with address modes set.
100    #[inline]
101    pub const fn address_modes(
102        mut self,
103        address_u: AddressMode,
104        address_v: AddressMode,
105        address_w: AddressMode,
106    ) -> Self {
107        self.address_u = address_u;
108        self.address_v = address_v;
109        self.address_w = address_w;
110        self
111    }
112
113    /// Returns this sampler with anisotropy clamped to `1..=16`.
114    #[inline]
115    pub const fn anisotropy(mut self, anisotropy: u8) -> Self {
116        self.anisotropy = if anisotropy < 1 {
117            1
118        } else if anisotropy > 16 {
119            16
120        } else {
121            anisotropy
122        };
123        self
124    }
125
126    /// Returns this sampler with a compare function.
127    #[inline]
128    pub const fn compare(mut self, compare: Option<CompareFunction>) -> Self {
129        self.compare = compare;
130        self
131    }
132}
133
134impl Default for Sampler {
135    #[inline]
136    fn default() -> Self {
137        Self::new()
138    }
139}