]> git.tdb.fi Git - libs/gl.git/blob - source/core/sampler.cpp
Replace the instance variables of exporters by function parameters
[libs/gl.git] / source / core / sampler.cpp
1 #include <msp/strings/format.h>
2 #include "error.h"
3 #include "sampler.h"
4
5 using namespace std;
6
7 namespace Msp {
8 namespace GL {
9
10 void Sampler::update() const
11 {
12         SamplerBackend::update(dirty_params);
13         dirty_params = 0;
14 }
15
16 void Sampler::set_min_filter(TextureFilter f)
17 {
18         min_filter = f;
19         dirty_params |= MIN_FILTER;
20 }
21
22 void Sampler::set_mag_filter(TextureFilter f)
23 {
24         mag_filter = f;
25         dirty_params |= MAG_FILTER;
26 }
27
28 void Sampler::set_filter(TextureFilter f)
29 {
30         set_min_filter(f);
31         set_mag_filter(f==NEAREST ? NEAREST : LINEAR);
32 }
33
34 void Sampler::set_max_anisotropy(float a)
35 {
36         if(a<1.0f)
37                 throw invalid_argument("Sampler::set_max_anisotropy");
38         bool supported = check_anisotropic(a>1.0f);
39         max_anisotropy = a;
40         if(supported)
41                 dirty_params |= MAX_ANISOTROPY;
42 }
43
44 void Sampler::set_wrap(TextureWrap w)
45 {
46         set_wrap_s(w);
47         set_wrap_t(w);
48         set_wrap_r(w);
49 }
50
51 void Sampler::set_wrap_s(TextureWrap w)
52 {
53         wrap_s = w;
54         dirty_params |= WRAP_S;
55 }
56
57 void Sampler::set_wrap_t(TextureWrap w)
58 {
59         wrap_t = w;
60         dirty_params |= WRAP_T;
61 }
62
63 void Sampler::set_wrap_r(TextureWrap w)
64 {
65         wrap_r = w;
66         dirty_params |= WRAP_R;
67 }
68
69 void Sampler::set_border_color(const Color &c)
70 {
71         border_color = c;
72         dirty_params |= BORDER_COLOR;
73 }
74
75 void Sampler::disable_compare()
76 {
77         compare = false;
78         dirty_params |= COMPARE;
79 }
80
81 void Sampler::set_compare(Predicate f)
82 {
83         compare = true;
84         cmp_func = f;
85         dirty_params |= COMPARE;
86 }
87
88
89 Sampler::Loader::Loader(Sampler &s):
90         DataFile::ObjectLoader<Sampler>(s)
91 {
92         add("border_color", &Loader::border_color);
93         add("compare", &Loader::compare);
94         add("filter", &Loader::filter);
95         add("mag_filter", &Loader::mag_filter);
96         add("max_anisotropy", &Loader::max_anisotropy);
97         add("min_filter", &Loader::min_filter);
98         add("wrap", &Loader::wrap);
99         add("wrap_r", &Loader::wrap_r);
100         add("wrap_s", &Loader::wrap_s);
101         add("wrap_t", &Loader::wrap_t);
102 }
103
104 void Sampler::Loader::border_color(float r, float g, float b, float a)
105 {
106         obj.set_border_color(Color(r, g, b, a));
107 }
108
109 void Sampler::Loader::compare(Predicate c)
110 {
111         obj.set_compare(c);
112 }
113
114 void Sampler::Loader::filter(TextureFilter f)
115 {
116         obj.set_filter(f);
117 }
118
119 void Sampler::Loader::mag_filter(TextureFilter f)
120 {
121         obj.set_mag_filter(f);
122 }
123
124 void Sampler::Loader::max_anisotropy(float a)
125 {
126         obj.set_max_anisotropy(a);
127 }
128
129 void Sampler::Loader::min_filter(TextureFilter f)
130 {
131         obj.set_min_filter(f);
132 }
133
134 void Sampler::Loader::wrap(TextureWrap w)
135 {
136         obj.set_wrap(w);
137 }
138
139 void Sampler::Loader::wrap_r(TextureWrap w)
140 {
141         obj.set_wrap_r(w);
142 }
143
144 void Sampler::Loader::wrap_s(TextureWrap w)
145 {
146         obj.set_wrap_s(w);
147 }
148
149 void Sampler::Loader::wrap_t(TextureWrap w)
150 {
151         obj.set_wrap_t(w);
152 }
153
154
155 bool is_mipmapped(TextureFilter filter)
156 {
157         return (filter==NEAREST_MIPMAP_NEAREST || filter==NEAREST_MIPMAP_LINEAR ||
158                 filter==LINEAR_MIPMAP_NEAREST || filter==LINEAR_MIPMAP_LINEAR);
159 }
160
161 void operator>>(const LexicalConverter &c, TextureFilter &tf)
162 {
163         if(c.get()=="NEAREST")
164                 tf = NEAREST;
165         else if(c.get()=="LINEAR")
166                 tf = LINEAR;
167         else if(c.get()=="NEAREST_MIPMAP_NEAREST")
168                 tf = NEAREST_MIPMAP_NEAREST;
169         else if(c.get()=="NEAREST_MIPMAP_LINEAR")
170                 tf = NEAREST_MIPMAP_LINEAR;
171         else if(c.get()=="LINEAR_MIPMAP_NEAREST")
172                 tf = LINEAR_MIPMAP_NEAREST;
173         else if(c.get()=="LINEAR_MIPMAP_LINEAR")
174                 tf = LINEAR_MIPMAP_LINEAR;
175         else
176                 throw lexical_error(format("conversion of '%s' to TextureFilter", c.get()));
177 }
178
179 void operator>>(const LexicalConverter &c, TextureWrap &tw)
180 {
181         if(c.get()=="REPEAT")
182                 tw = REPEAT;
183         else if(c.get()=="CLAMP_TO_EDGE")
184                 tw = CLAMP_TO_EDGE;
185         else if(c.get()=="CLAMP_TO_BORDER")
186                 tw = CLAMP_TO_BORDER;
187         else if(c.get()=="MIRRORED_REPEAT")
188                 tw = MIRRORED_REPEAT;
189         else
190                 throw lexical_error(format("conversion of '%s' to TextureWrap", c.get()));
191 }
192
193
194 } // namespace GL
195 } // namespace Msp