]> git.tdb.fi Git - libs/gl.git/blob - source/texture.cpp
820dd10fd90318c64278ae9b0aed66cf227d8743
[libs/gl.git] / source / texture.cpp
1 #include <msp/gl/extensions/arb_direct_state_access.h>
2 #include <msp/gl/extensions/arb_shadow.h>
3 #include <msp/gl/extensions/arb_texture_swizzle.h>
4 #include <msp/gl/extensions/ext_framebuffer_object.h>
5 #include <msp/gl/extensions/ext_texture3d.h>
6 #include <msp/gl/extensions/ext_texture_filter_anisotropic.h>
7 #include <msp/gl/extensions/sgis_generate_mipmap.h>
8 #include <msp/io/memory.h>
9 #include <msp/strings/format.h>
10 #include "error.h"
11 #include "resourcemanager.h"
12 #include "resources.h"
13 #include "texture.h"
14 #include "texunit.h"
15
16 using namespace std;
17
18 namespace Msp {
19 namespace GL {
20
21 void operator>>(const LexicalConverter &c, TextureFilter &tf)
22 {
23         if(c.get()=="NEAREST")
24                 tf = NEAREST;
25         else if(c.get()=="LINEAR")
26                 tf = LINEAR;
27         else if(c.get()=="NEAREST_MIPMAP_NEAREST")
28                 tf = NEAREST_MIPMAP_NEAREST;
29         else if(c.get()=="NEAREST_MIPMAP_LINEAR")
30                 tf = NEAREST_MIPMAP_LINEAR;
31         else if(c.get()=="LINEAR_MIPMAP_NEAREST")
32                 tf = LINEAR_MIPMAP_NEAREST;
33         else if(c.get()=="LINEAR_MIPMAP_LINEAR")
34                 tf = LINEAR_MIPMAP_LINEAR;
35         else
36                 throw lexical_error(format("conversion of '%s' to TextureFilter", c.get()));
37 }
38
39
40 void operator>>(const LexicalConverter &c, TextureWrap &tw)
41 {
42         if(c.get()=="REPEAT")
43                 tw = REPEAT;
44         else if(c.get()=="CLAMP_TO_EDGE")
45                 tw = CLAMP_TO_EDGE;
46         else if(c.get()=="MIRRORED_REPEAT")
47                 tw = MIRRORED_REPEAT;
48         else
49                 throw lexical_error(format("conversion of '%s' to TextureWrap", c.get()));
50 }
51
52
53 int Texture::swizzle_orders[] =
54 {
55         GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA,
56         GL_RED, GL_RED, GL_RED, GL_ONE,
57         GL_RED, GL_RED, GL_RED, GL_GREEN
58 };
59
60 Texture::Texture(GLenum t, ResourceManager *m):
61         id(0),
62         target(t),
63         ifmt(RGB),
64         min_filter(NEAREST_MIPMAP_LINEAR),
65         mag_filter(LINEAR),
66         max_anisotropy(1.0f),
67         wrap_s(REPEAT),
68         wrap_t(REPEAT),
69         wrap_r(REPEAT),
70         gen_mipmap(false),
71         compare(false),
72         cmp_func(LEQUAL),
73         dirty_params(0)
74 {
75         if(m)
76                 set_manager(m);
77         else if(ARB_direct_state_access)
78                 glCreateTextures(target, 1, &id);
79         else
80                 glGenTextures(1, &id);
81 }
82
83 Texture::~Texture()
84 {
85         while(TexUnit *unit = TexUnit::find_unit(this))
86                 unbind_from(unit->get_index());
87
88         if(id)
89                 glDeleteTextures(1, &id);
90 }
91
92 DataType Texture::get_alloc_type(PixelFormat fmt)
93 {
94         return (get_base_pixelformat(fmt)==DEPTH_COMPONENT ? UNSIGNED_SHORT : UNSIGNED_BYTE);
95 }
96
97 void Texture::set_internal_format(PixelFormat fmt)
98 {
99         if(!get_component_size(fmt) && OES_required_internalformat)
100                 fmt = get_default_sized_pixelformat(fmt);
101
102         FormatSwizzle swiz = NO_SWIZZLE;
103         if(ARB_texture_rg && ARB_texture_swizzle)
104         {
105                 if(fmt==LUMINANCE8 || fmt==SLUMINANCE8)
106                 {
107                         fmt = R8;
108                         swiz = R_TO_LUMINANCE;
109                 }
110                 else if(fmt==LUMINANCE8_ALPHA8 || fmt==SLUMINANCE8_ALPHA8)
111                 {
112                         fmt = RG8;
113                         swiz = RG_TO_LUMINANCE_ALPHA;
114                 }
115         }
116
117         require_pixelformat(fmt);
118         ifmt = fmt;
119         swizzle = swiz;
120         if(swizzle)
121                 update_parameter(FORMAT_SWIZZLE);
122 }
123
124 PixelFormat Texture::get_upload_format(PixelFormat fmt) const
125 {
126         if(fmt==LUMINANCE || fmt==LUMINANCE_ALPHA)
127                 return get_base_pixelformat(ifmt);
128         else
129                 return fmt;
130 }
131
132 void Texture::update_parameter(int mask) const
133 {
134         if(!ARB_direct_state_access && TexUnit::current().get_texture()!=this)
135         {
136                 TexUnit *unit = TexUnit::find_unit(this);
137                 if(!unit)
138                 {
139                         dirty_params |= mask;
140                         return;
141                 }
142
143                 unit->bind();
144         }
145
146         if(mask&MIN_FILTER)
147                 set_parameter_i(GL_TEXTURE_MIN_FILTER, min_filter);
148         if(mask&MAG_FILTER)
149                 set_parameter_i(GL_TEXTURE_MAG_FILTER, mag_filter);
150         if(mask&MAX_ANISOTROPY)
151                 set_parameter_f(GL_TEXTURE_MAX_ANISOTROPY_EXT, max_anisotropy);
152         if(mask&WRAP_S)
153                 set_parameter_i(GL_TEXTURE_WRAP_S, wrap_s);
154         if(mask&WRAP_T)
155                 set_parameter_i(GL_TEXTURE_WRAP_T, wrap_t);
156         if(mask&WRAP_R)
157                 set_parameter_i(GL_TEXTURE_WRAP_R, wrap_r);
158         if(mask&GENERATE_MIPMAP)
159                 set_parameter_i(GL_GENERATE_MIPMAP, gen_mipmap);
160         if(mask&COMPARE)
161                 set_parameter_i(GL_TEXTURE_COMPARE_MODE, (compare ? GL_COMPARE_R_TO_TEXTURE : GL_NONE));
162         if(mask&COMPARE_FUNC)
163                 set_parameter_i(GL_TEXTURE_COMPARE_FUNC, cmp_func);
164         if(mask&FORMAT_SWIZZLE)
165         {
166                 if(get_gl_api()==OPENGL_ES2)
167                 {
168                         set_parameter_i(GL_TEXTURE_SWIZZLE_R, swizzle_orders[swizzle*4]);
169                         set_parameter_i(GL_TEXTURE_SWIZZLE_G, swizzle_orders[swizzle*4+1]);
170                         set_parameter_i(GL_TEXTURE_SWIZZLE_B, swizzle_orders[swizzle*4+2]);
171                         set_parameter_i(GL_TEXTURE_SWIZZLE_A, swizzle_orders[swizzle*4+3]);
172                 }
173                 else
174                 {
175                         if(ARB_direct_state_access)
176                                 glTextureParameteriv(id, GL_TEXTURE_SWIZZLE_RGBA, swizzle_orders+swizzle*4);
177                         else
178                                 glTexParameteriv(target, GL_TEXTURE_SWIZZLE_RGBA, swizzle_orders+swizzle*4);
179                 }
180         }
181 }
182
183 void Texture::set_parameter_i(GLenum param, int value) const
184 {
185         if(ARB_direct_state_access)
186                 glTextureParameteri(id, param, value);
187         else
188                 glTexParameteri(target, param, value);
189 }
190
191 void Texture::set_parameter_f(GLenum param, float value) const
192 {
193         if(ARB_direct_state_access)
194                 glTextureParameterf(id, param, value);
195         else
196                 glTexParameterf(target, param, value);
197 }
198
199 void Texture::set_min_filter(TextureFilter f)
200 {
201         min_filter = f;
202         update_parameter(MIN_FILTER);
203 }
204
205 void Texture::set_mag_filter(TextureFilter f)
206 {
207         mag_filter = f;
208         update_parameter(MAG_FILTER);
209 }
210
211 void Texture::set_filter(TextureFilter f)
212 {
213         set_min_filter(f);
214         set_mag_filter(f==NEAREST ? NEAREST : LINEAR);
215 }
216
217 void Texture::set_max_anisotropy(float a)
218 {
219         if(a<1.0f)
220                 throw invalid_argument("Texture::set_max_anisotropy");
221         else if(a>1.0f)
222                 static Require _req(EXT_texture_filter_anisotropic);
223         max_anisotropy = a;
224         if(EXT_texture_filter_anisotropic)
225                 update_parameter(MAX_ANISOTROPY);
226 }
227
228 void Texture::set_wrap(TextureWrap w)
229 {
230         set_wrap_s(w);
231         set_wrap_t(w);
232         if(EXT_texture3D)
233                 set_wrap_r(w);
234 }
235
236 void Texture::set_wrap_s(TextureWrap w)
237 {
238         wrap_s = w;
239         update_parameter(WRAP_S);
240 }
241
242 void Texture::set_wrap_t(TextureWrap w)
243 {
244         wrap_t = w;
245         update_parameter(WRAP_T);
246 }
247
248 void Texture::set_wrap_r(TextureWrap w)
249 {
250         static Require _req(EXT_texture3D);
251         wrap_r = w;
252         update_parameter(WRAP_R);
253 }
254
255 bool Texture::can_generate_mipmap()
256 {
257         return (EXT_framebuffer_object || SGIS_generate_mipmap);
258 }
259
260 void Texture::set_generate_mipmap(bool gm)
261 {
262         if(gm && !EXT_framebuffer_object)
263                 static Require _req(SGIS_generate_mipmap);
264         gen_mipmap = gm;
265         if(!EXT_framebuffer_object)
266                 update_parameter(GENERATE_MIPMAP);
267 }
268
269 void Texture::auto_generate_mipmap()
270 {
271         // glGenerateMipmap is defined here
272         if(EXT_framebuffer_object)
273         {
274                 if(ARB_direct_state_access)
275                         glGenerateTextureMipmap(id);
276                 else
277                         glGenerateMipmap(target);
278         }
279 }
280
281 void Texture::set_compare_enabled(bool c)
282 {
283         if(c)
284                 static Require _req(ARB_shadow);
285         compare = c;
286         update_parameter(COMPARE);
287 }
288
289 void Texture::set_compare_func(Predicate f)
290 {
291         static Require _req(ARB_shadow);
292         cmp_func = f;
293         update_parameter(COMPARE_FUNC);
294 }
295
296 void Texture::load_image(const string &fn, bool srgb)
297 {
298         Graphics::Image img;
299         img.load_file(fn);
300
301         image(img, srgb);
302 }
303
304 void Texture::bind_to(unsigned i, bool legacy) const
305 {
306         if(!id)
307         {
308                 if(manager)
309                         manager->resource_used(*this);
310                 if(!id)
311                 {
312                         unbind_from(i);
313                         return;
314                 }
315         }
316
317         legacy = (legacy && is_legacy_target(target));
318
319         TexUnit &unit = TexUnit::get_unit(i);
320         const Texture *old = unit.get_texture();
321         bool old_legacy = unit.get_texture_legacy();
322         if(unit.set_texture(this, legacy))
323         {
324                 if(manager)
325                         manager->resource_used(*this);
326
327                 if(ARB_direct_state_access && !old_legacy && (!unit.supports_legacy() || !legacy))
328                         glBindTextureUnit(i, id);
329                 else
330                 {
331                         unit.bind();
332                         if(unit.supports_legacy())
333                         {
334                                 if(old && old->target!=target && old_legacy)
335                                         glDisable(old->target);
336                                 if((!old || old->target!=target) && legacy)
337                                         glEnable(target);
338                         }
339                         glBindTexture(target, id);
340                 }
341
342                 if(dirty_params)
343                 {
344                         update_parameter(dirty_params);
345                         dirty_params = 0;
346                 }
347         }
348 }
349
350 const Texture *Texture::current(unsigned i)
351 {
352         return TexUnit::get_unit(i).get_texture();
353 }
354
355 void Texture::unbind_from(unsigned i)
356 {
357         TexUnit &unit = TexUnit::get_unit(i);
358         const Texture *cur = unit.get_texture();
359         bool legacy = unit.get_texture_legacy();
360         if(unit.set_texture(0))
361         {
362                 if(ARB_direct_state_access && !legacy)
363                         glBindTextureUnit(i, 0);
364                 else
365                 {
366                         unit.bind();
367                         glBindTexture(cur->target, 0);
368                         if(unit.supports_legacy() && legacy)
369                                 glDisable(cur->target);
370                 }
371         }
372 }
373
374 bool Texture::is_legacy_target(GLenum target)
375 {
376         return target<GL_TEXTURE_1D_ARRAY;
377 }
378
379
380 Texture::Loader::Loader(Texture &t):
381         DataFile::CollectionObjectLoader<Texture>(t, 0)
382 {
383         init();
384 }
385
386 Texture::Loader::Loader(Texture &t, Collection &c):
387         DataFile::CollectionObjectLoader<Texture>(t, &c)
388 {
389         init();
390 }
391
392 void Texture::Loader::init()
393 {
394         if(Resources *res = dynamic_cast<Resources *>(coll))
395                 srgb = res->get_srgb_conversion();
396         else
397                 srgb = false;
398
399         add("external_image", &Loader::external_image);
400         add("filter", &Loader::filter);
401         add("generate_mipmap", &Loader::generate_mipmap);
402         add("image_data", &Loader::image_data);
403         add("mag_filter", &Loader::mag_filter);
404         add("max_anisotropy", &Loader::max_anisotropy);
405         add("min_filter", &Loader::min_filter);
406         add("wrap",       &Loader::wrap);
407         add("wrap_r",     &Loader::wrap_r);
408         add("wrap_s",     &Loader::wrap_s);
409         add("wrap_t",     &Loader::wrap_t);
410 }
411
412 void Texture::Loader::external_image(const string &fn)
413 {
414         Graphics::Image img;
415         RefPtr<IO::Seekable> io = get_collection().open_raw(fn);
416         img.load_io(*io);
417
418         obj.image(img, srgb);
419 }
420
421 void Texture::Loader::filter(TextureFilter f)
422 {
423         obj.set_filter(f);
424 }
425
426 void Texture::Loader::generate_mipmap(bool gm)
427 {
428         obj.set_generate_mipmap(gm);
429 }
430
431 void Texture::Loader::image_data(const string &data)
432 {
433         Graphics::Image img;
434         IO::Memory mem(data.data(), data.size());
435         img.load_io(mem);
436
437         obj.image(img, srgb);
438 }
439
440 void Texture::Loader::mag_filter(TextureFilter f)
441 {
442         obj.set_mag_filter(f);
443 }
444
445 void Texture::Loader::max_anisotropy(float a)
446 {
447         obj.set_max_anisotropy(a);
448 }
449
450 void Texture::Loader::min_filter(TextureFilter f)
451 {
452         obj.set_min_filter(f);
453 }
454
455 void Texture::Loader::wrap(TextureWrap w)
456 {
457         obj.set_wrap(w);
458 }
459
460 void Texture::Loader::wrap_r(TextureWrap w)
461 {
462         obj.set_wrap_r(w);
463 }
464
465 void Texture::Loader::wrap_s(TextureWrap w)
466 {
467         obj.set_wrap_s(w);
468 }
469
470 void Texture::Loader::wrap_t(TextureWrap w)
471 {
472         obj.set_wrap_t(w);
473 }
474
475
476 bool is_mipmapped(TextureFilter filter)
477 {
478         return (filter==NEAREST_MIPMAP_NEAREST || filter==NEAREST_MIPMAP_LINEAR ||
479                 filter==LINEAR_MIPMAP_NEAREST || filter==LINEAR_MIPMAP_LINEAR);
480 }
481
482 } // namespace GL
483 } // namespace Msp