naga/back/msl/
sampler.rs

1use core::{num::NonZeroU32, ops::Range};
2
3#[cfg(feature = "deserialize")]
4use serde::Deserialize;
5#[cfg(feature = "serialize")]
6use serde::Serialize;
7
8#[derive(Clone, Copy, Default, Debug, PartialEq, Eq, Hash)]
9#[cfg_attr(feature = "serialize", derive(Serialize))]
10#[cfg_attr(feature = "deserialize", derive(Deserialize))]
11pub enum Coord {
12    #[default]
13    Normalized,
14    Pixel,
15}
16
17impl Coord {
18    pub const fn as_str(&self) -> &'static str {
19        match *self {
20            Self::Normalized => "normalized",
21            Self::Pixel => "pixel",
22        }
23    }
24}
25
26#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
27#[cfg_attr(feature = "serialize", derive(Serialize))]
28#[cfg_attr(feature = "deserialize", derive(Deserialize))]
29pub enum Address {
30    Repeat,
31    MirroredRepeat,
32    #[default]
33    ClampToEdge,
34    ClampToZero,
35    ClampToBorder,
36}
37
38impl Address {
39    pub const fn as_str(&self) -> &'static str {
40        match *self {
41            Self::Repeat => "repeat",
42            Self::MirroredRepeat => "mirrored_repeat",
43            Self::ClampToEdge => "clamp_to_edge",
44            Self::ClampToZero => "clamp_to_zero",
45            Self::ClampToBorder => "clamp_to_border",
46        }
47    }
48}
49
50#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
51#[cfg_attr(feature = "serialize", derive(Serialize))]
52#[cfg_attr(feature = "deserialize", derive(Deserialize))]
53pub enum BorderColor {
54    #[default]
55    TransparentBlack,
56    OpaqueBlack,
57    OpaqueWhite,
58}
59
60impl BorderColor {
61    pub const fn as_str(&self) -> &'static str {
62        match *self {
63            Self::TransparentBlack => "transparent_black",
64            Self::OpaqueBlack => "opaque_black",
65            Self::OpaqueWhite => "opaque_white",
66        }
67    }
68}
69
70#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
71#[cfg_attr(feature = "serialize", derive(Serialize))]
72#[cfg_attr(feature = "deserialize", derive(Deserialize))]
73pub enum Filter {
74    #[default]
75    Nearest,
76    Linear,
77}
78
79impl Filter {
80    pub const fn as_str(&self) -> &'static str {
81        match *self {
82            Self::Nearest => "nearest",
83            Self::Linear => "linear",
84        }
85    }
86}
87
88#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
89#[cfg_attr(feature = "serialize", derive(Serialize))]
90#[cfg_attr(feature = "deserialize", derive(Deserialize))]
91pub enum CompareFunc {
92    #[default]
93    Never,
94    Less,
95    LessEqual,
96    Greater,
97    GreaterEqual,
98    Equal,
99    NotEqual,
100    Always,
101}
102
103impl CompareFunc {
104    pub const fn as_str(&self) -> &'static str {
105        match *self {
106            Self::Never => "never",
107            Self::Less => "less",
108            Self::LessEqual => "less_equal",
109            Self::Greater => "greater",
110            Self::GreaterEqual => "greater_equal",
111            Self::Equal => "equal",
112            Self::NotEqual => "not_equal",
113            Self::Always => "always",
114        }
115    }
116}
117
118#[derive(Clone, Debug, Default, PartialEq)]
119#[cfg_attr(feature = "serialize", derive(Serialize))]
120#[cfg_attr(feature = "deserialize", derive(Deserialize))]
121pub struct InlineSampler {
122    pub coord: Coord,
123    pub address: [Address; 3],
124    pub border_color: BorderColor,
125    pub mag_filter: Filter,
126    pub min_filter: Filter,
127    pub mip_filter: Option<Filter>,
128    pub lod_clamp: Option<Range<f32>>,
129    pub max_anisotropy: Option<NonZeroU32>,
130    pub compare_func: CompareFunc,
131}
132
133impl Eq for InlineSampler {}
134
135#[allow(renamed_and_removed_lints)]
136#[allow(clippy::derive_hash_xor_eq)]
137impl core::hash::Hash for InlineSampler {
138    fn hash<H: core::hash::Hasher>(&self, hasher: &mut H) {
139        self.coord.hash(hasher);
140        self.address.hash(hasher);
141        self.border_color.hash(hasher);
142        self.mag_filter.hash(hasher);
143        self.min_filter.hash(hasher);
144        self.mip_filter.hash(hasher);
145        self.lod_clamp
146            .as_ref()
147            .map(|range| (range.start.to_bits(), range.end.to_bits()))
148            .hash(hasher);
149        self.max_anisotropy.hash(hasher);
150        self.compare_func.hash(hasher);
151    }
152}