kero 0.1.12

A simple, approachable framework for creating 2D games in Rust and/or Lua.
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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use serde::{Deserialize, Serialize};
use strum::FromRepr;

/// A sampler type to be used by shaders.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
pub struct Sampler {
    /// Horizontal address mode.
    pub address_x: AddressMode,

    /// Vertical address mode.
    pub address_y: AddressMode,

    /// Filter mode when texture is scaling down.
    pub min_filter: FilterMode,

    /// Filter mode when texture is scaling up.
    pub mag_filter: FilterMode,
}

impl Default for Sampler {
    #[inline]
    fn default() -> Self {
        Self::new(
            AddressMode::Repeat,
            AddressMode::Repeat,
            FilterMode::Linear,
            FilterMode::Nearest,
        )
    }
}

impl Sampler {
    /// All possible sampler variants.
    #[inline]
    pub fn all() -> Vec<Self> {
        let mut samplers = Vec::new();
        for ax in AddressMode::VARIANTS {
            for ay in AddressMode::VARIANTS {
                for min in FilterMode::VARIANTS {
                    for mag in FilterMode::VARIANTS {
                        samplers.push(Self::new(ax, ay, min, mag));
                    }
                }
            }
        }
        samplers
    }

    /// Create a new sampler.
    #[inline]
    pub const fn new(
        address_x: AddressMode,
        address_y: AddressMode,
        min_filter: FilterMode,
        mag_filter: FilterMode,
    ) -> Self {
        Self {
            address_x,
            address_y,
            min_filter,
            mag_filter,
        }
    }

    /// Create a uniform x/y min/mag sampler.
    #[inline]
    pub const fn with(address: AddressMode, filter: FilterMode) -> Self {
        Self::new(address, address, filter, filter)
    }

    /// Create a clamped sampler with the selected filter mode.
    #[inline]
    pub const fn clamp(filter: FilterMode) -> Self {
        Self::with(AddressMode::Clamp, filter)
    }

    /// Create a repeating sampler with the selected filter mode.
    #[inline]
    pub const fn repeat(filter: FilterMode) -> Self {
        Self::with(AddressMode::Repeat, filter)
    }

    /// Create a nearest sampler with the selected address mode.
    #[inline]
    pub const fn nearest(address: AddressMode) -> Self {
        Self::with(address, FilterMode::Nearest)
    }

    /// Create a linear sampler with the selected address mode.
    #[inline]
    pub const fn linear(address: AddressMode) -> Self {
        Self::with(address, FilterMode::Linear)
    }
}

/// How edges should be handled in texture addressing.
#[derive(
    Debug, Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize,
)]
pub enum AddressMode {
    #[default]
    Clamp,
    Repeat,
    MirrorRepeat,
}

impl Into<wgpu::AddressMode> for AddressMode {
    #[inline]
    fn into(self) -> wgpu::AddressMode {
        match self {
            Self::Clamp => wgpu::AddressMode::ClampToEdge,
            Self::Repeat => wgpu::AddressMode::Repeat,
            Self::MirrorRepeat => wgpu::AddressMode::MirrorRepeat,
        }
    }
}

impl AddressMode {
    pub const VARIANTS: [Self; 3] = [Self::Clamp, Self::Repeat, Self::MirrorRepeat];
}

/// Texel mixing mode when sampling between texels.
#[derive(
    Debug,
    Default,
    Copy,
    Clone,
    Eq,
    PartialEq,
    Ord,
    PartialOrd,
    Hash,
    Serialize,
    Deserialize,
    FromRepr,
)]
pub enum FilterMode {
    #[default]
    Nearest,
    Linear,
}

impl Into<wgpu::FilterMode> for FilterMode {
    #[inline]
    fn into(self) -> wgpu::FilterMode {
        match self {
            Self::Nearest => wgpu::FilterMode::Nearest,
            Self::Linear => wgpu::FilterMode::Linear,
        }
    }
}

impl FilterMode {
    pub const VARIANTS: [Self; 2] = [Self::Nearest, Self::Linear];
}