]> git.tdb.fi Git - libs/gl.git/blob - source/texture.cpp
Support user clip planes in generated shaders
[libs/gl.git] / source / texture.cpp
1 #include <msp/gl/extensions/arb_shadow.h>
2 #include <msp/gl/extensions/ext_framebuffer_object.h>
3 #include <msp/gl/extensions/ext_texture3d.h>
4 #include <msp/gl/extensions/ext_texture_filter_anisotropic.h>
5 #include <msp/gl/extensions/sgis_generate_mipmap.h>
6 #include <msp/strings/format.h>
7 #include "error.h"
8 #include "resourcemanager.h"
9 #include "resources.h"
10 #include "texture.h"
11 #include "texunit.h"
12
13 using namespace std;
14
15 namespace Msp {
16 namespace GL {
17
18 void operator>>(const LexicalConverter &c, TextureFilter &tf)
19 {
20         if(c.get()=="NEAREST")
21                 tf = NEAREST;
22         else if(c.get()=="LINEAR")
23                 tf = LINEAR;
24         else if(c.get()=="NEAREST_MIPMAP_NEAREST")
25                 tf = NEAREST_MIPMAP_NEAREST;
26         else if(c.get()=="NEAREST_MIPMAP_LINEAR")
27                 tf = NEAREST_MIPMAP_LINEAR;
28         else if(c.get()=="LINEAR_MIPMAP_NEAREST")
29                 tf = LINEAR_MIPMAP_NEAREST;
30         else if(c.get()=="LINEAR_MIPMAP_LINEAR")
31                 tf = LINEAR_MIPMAP_LINEAR;
32         else
33                 throw lexical_error(format("conversion of '%s' to TextureFilter", c.get()));
34 }
35
36
37 void operator>>(const LexicalConverter &c, TextureWrap &tw)
38 {
39         if(c.get()=="REPEAT")
40                 tw = REPEAT;
41         else if(c.get()=="CLAMP_TO_EDGE")
42                 tw = CLAMP_TO_EDGE;
43         else if(c.get()=="MIRRORED_REPEAT")
44                 tw = MIRRORED_REPEAT;
45         else
46                 throw lexical_error(format("conversion of '%s' to TextureWrap", c.get()));
47 }
48
49
50 Texture::Texture(GLenum t, ResourceManager *m):
51         id(0),
52         target(t),
53         min_filter(NEAREST_MIPMAP_LINEAR),
54         mag_filter(LINEAR),
55         wrap_s(REPEAT),
56         wrap_t(REPEAT),
57         wrap_r(REPEAT),
58         gen_mipmap(false),
59         compare(false),
60         cmp_func(LEQUAL),
61         dirty_params(0)
62 {
63         if(m)
64                 set_manager(m);
65         else
66                 glGenTextures(1, &id);
67 }
68
69 Texture::~Texture()
70 {
71         while(TexUnit *unit = TexUnit::find_unit(this))
72                 unbind_from(unit->get_index());
73
74         if(id)
75                 glDeleteTextures(1, &id);
76 }
77
78 DataType Texture::get_alloc_type(PixelFormat fmt)
79 {
80         return (fmt==DEPTH_COMPONENT ? UNSIGNED_SHORT : UNSIGNED_BYTE);
81 }
82
83 void Texture::update_parameter(int mask) const
84 {
85         if(TexUnit::current().get_texture()!=this)
86         {
87                 TexUnit *unit = TexUnit::find_unit(this);
88                 if(!unit)
89                 {
90                         dirty_params |= mask;
91                         return;
92                 }
93
94                 unit->bind();
95         }
96
97         if(mask&MIN_FILTER)
98                 glTexParameteri(target, GL_TEXTURE_MIN_FILTER, min_filter);
99         if(mask&MAG_FILTER)
100                 glTexParameteri(target, GL_TEXTURE_MAG_FILTER, mag_filter);
101         if(mask&MAX_ANISOTROPY)
102                 glTexParameteri(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropy);
103         if(mask&WRAP_S)
104                 glTexParameteri(target, GL_TEXTURE_WRAP_S, wrap_s);
105         if(mask&WRAP_T)
106                 glTexParameteri(target, GL_TEXTURE_WRAP_T, wrap_t);
107         if(mask&WRAP_R)
108                 glTexParameteri(target, GL_TEXTURE_WRAP_R, wrap_r);
109         if(mask&GENERATE_MIPMAP)
110                 glTexParameteri(target, GL_GENERATE_MIPMAP, gen_mipmap);
111         if(mask&COMPARE)
112                 glTexParameteri(target, GL_TEXTURE_COMPARE_MODE, (compare ? GL_COMPARE_R_TO_TEXTURE : GL_NONE));
113         if(mask&COMPARE_FUNC)
114                 glTexParameteri(target, GL_TEXTURE_COMPARE_FUNC, cmp_func);
115 }
116
117 void Texture::set_min_filter(TextureFilter f)
118 {
119         min_filter = f;
120         update_parameter(MIN_FILTER);
121 }
122
123 void Texture::set_mag_filter(TextureFilter f)
124 {
125         mag_filter = f;
126         update_parameter(MAG_FILTER);
127 }
128
129 void Texture::set_filter(TextureFilter f)
130 {
131         set_min_filter(f);
132         set_mag_filter(f==NEAREST ? NEAREST : LINEAR);
133 }
134
135 void Texture::set_max_anisotropy(float a)
136 {
137         if(a<1.0f)
138                 throw invalid_argument("Texture::set_max_anisotropy");
139         else if(a>1.0f)
140                 static Require _req(EXT_texture_filter_anisotropic);
141         max_anisotropy = a;
142         update_parameter(MAX_ANISOTROPY);
143 }
144
145 void Texture::set_wrap(TextureWrap w)
146 {
147         set_wrap_s(w);
148         set_wrap_t(w);
149         if(EXT_texture3D)
150                 set_wrap_r(w);
151 }
152
153 void Texture::set_wrap_s(TextureWrap w)
154 {
155         wrap_s = w;
156         update_parameter(WRAP_S);
157 }
158
159 void Texture::set_wrap_t(TextureWrap w)
160 {
161         wrap_t = w;
162         update_parameter(WRAP_T);
163 }
164
165 void Texture::set_wrap_r(TextureWrap w)
166 {
167         static Require _req(EXT_texture3D);
168         wrap_r = w;
169         update_parameter(WRAP_R);
170 }
171
172 void Texture::set_generate_mipmap(bool gm)
173 {
174         if(gm)
175                 static Require _req(SGIS_generate_mipmap);
176         gen_mipmap = gm;
177         if(get_gl_api()!=OPENGL_ES2)
178                 update_parameter(GENERATE_MIPMAP);
179 }
180
181 void Texture::auto_generate_mipmap()
182 {
183         if(get_gl_api()==OPENGL_ES2)
184         {
185                 // glGenerateMipmap is defined here
186                 static Require _req(EXT_framebuffer_object);
187                 glGenerateMipmap(target);
188         }
189 }
190
191 void Texture::set_compare_enabled(bool c)
192 {
193         if(c)
194                 static Require _req(ARB_shadow);
195         compare = c;
196         update_parameter(COMPARE);
197 }
198
199 void Texture::set_compare_func(Predicate f)
200 {
201         static Require _req(ARB_shadow);
202         cmp_func = f;
203         update_parameter(COMPARE_FUNC);
204 }
205
206 void Texture::bind_to(unsigned i) const
207 {
208         if(!id)
209         {
210                 if(manager)
211                         manager->resource_used(*this);
212                 if(!id)
213                 {
214                         unbind_from(i);
215                         return;
216                 }
217         }
218
219         TexUnit &unit = TexUnit::get_unit(i);
220         const Texture *old = unit.get_texture();
221         if(unit.set_texture(this))
222         {
223                 if(manager)
224                         manager->resource_used(*this);
225
226                 unit.bind();
227                 if(unit.supports_legacy())
228                 {
229                         if(old && old->target!=target)
230                                 glDisable(old->target);
231                         if(!old || old->target!=target)
232                                 glEnable(target);
233                 }
234                 glBindTexture(target, id);
235
236                 if(dirty_params)
237                 {
238                         update_parameter(dirty_params);
239                         dirty_params = 0;
240                 }
241         }
242 }
243
244 const Texture *Texture::current(unsigned i)
245 {
246         return TexUnit::get_unit(i).get_texture();
247 }
248
249 void Texture::unbind_from(unsigned i)
250 {
251         TexUnit &unit = TexUnit::get_unit(i);
252         const Texture *cur = unit.get_texture();
253         if(unit.set_texture(0))
254         {
255                 unit.bind();
256                 glBindTexture(cur->target, 0);
257                 if(unit.supports_legacy())
258                         glDisable(cur->target);
259         }
260 }
261
262
263 Texture::Loader::Loader(Texture &t):
264         DataFile::CollectionObjectLoader<Texture>(t, 0)
265 {
266         init();
267 }
268
269 Texture::Loader::Loader(Texture &t, Collection &c):
270         DataFile::CollectionObjectLoader<Texture>(t, &c)
271 {
272         init();
273 }
274
275 void Texture::Loader::init()
276 {
277         if(Resources *res = dynamic_cast<Resources *>(coll))
278                 srgb = res->get_srgb_conversion();
279         else
280                 srgb = false;
281
282         add("filter", &Loader::filter);
283         add("max_anisotropy", &Loader::max_anisotropy);
284         add("generate_mipmap", &Loader::generate_mipmap);
285         add("mag_filter", &Loader::mag_filter);
286         add("min_filter", &Loader::min_filter);
287         add("wrap",       &Loader::wrap);
288         add("wrap_r",     &Loader::wrap_r);
289         add("wrap_s",     &Loader::wrap_s);
290         add("wrap_t",     &Loader::wrap_t);
291 }
292
293 void Texture::Loader::filter(TextureFilter f)
294 {
295         obj.set_filter(f);
296 }
297
298 void Texture::Loader::generate_mipmap(bool gm)
299 {
300         obj.set_generate_mipmap(gm);
301 }
302
303 void Texture::Loader::mag_filter(TextureFilter f)
304 {
305         obj.set_mag_filter(f);
306 }
307
308 void Texture::Loader::max_anisotropy(float a)
309 {
310         obj.set_max_anisotropy(a);
311 }
312
313 void Texture::Loader::min_filter(TextureFilter f)
314 {
315         obj.set_min_filter(f);
316 }
317
318 void Texture::Loader::wrap(TextureWrap w)
319 {
320         obj.set_wrap(w);
321 }
322
323 void Texture::Loader::wrap_r(TextureWrap w)
324 {
325         obj.set_wrap_r(w);
326 }
327
328 void Texture::Loader::wrap_s(TextureWrap w)
329 {
330         obj.set_wrap_s(w);
331 }
332
333 void Texture::Loader::wrap_t(TextureWrap w)
334 {
335         obj.set_wrap_t(w);
336 }
337
338 } // namespace GL
339 } // namespace Msp