wider fov and smaller BALLZ
[ld37_one_room] / src / texture.cc
1 #include <math.h>
2 #include <assert.h>
3 #include "texture.h"
4 #include "datamap.h"
5 #include "image.h"
6 #include "opengl.h"
7 #include "imago2.h"
8 #include "logger.h"
9
10 static int glifmt_from_ifmt(unsigned int ifmt);
11 static int glfmt_from_ifmt(unsigned int ifmt);
12 static int gltype_from_ifmt(unsigned int ifmt);
13
14 static int glifmt_from_imgfmt(Image::Format fmt);
15
16 static unsigned int type_to_target(TextureType type);
17 static TextureType target_to_type(unsigned int targ);
18
19 static unsigned int cur_target[8] = {
20         GL_TEXTURE_2D, GL_TEXTURE_2D, GL_TEXTURE_2D, GL_TEXTURE_2D,
21         GL_TEXTURE_2D, GL_TEXTURE_2D, GL_TEXTURE_2D, GL_TEXTURE_2D
22 };
23
24 static unsigned int cube_faces[] = {
25         GL_TEXTURE_CUBE_MAP_POSITIVE_X,
26         GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
27         GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
28         GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
29         GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
30         GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
31 };
32
33
34 void bind_texture(Texture *tex, int tunit)
35 {
36         if(tex) {
37                 tex->bind(tunit);
38         } else {
39                 glActiveTexture(GL_TEXTURE0 + tunit);
40                 glBindTexture(cur_target[tunit], 0);
41                 assert(glGetError() == GL_NO_ERROR);
42                 glActiveTexture(GL_TEXTURE0);
43         }
44 }
45
46
47 Image *Texture::default_img;
48
49 Texture::Texture()
50 {
51         target = 0;
52         sz[0] = sz[1] = sz[2] = 0;
53         texfmt = 0;
54
55         img = 0;
56         glGenTextures(1, &id);
57 }
58
59 Texture::~Texture()
60 {
61         if(id) {
62                 glDeleteTextures(1, &id);
63         }
64         if(img) {
65                 delete img;
66         }
67 }
68
69 void Texture::set_wrapping(unsigned int wrap)
70 {
71         if(!target) {
72                 return;
73         }
74
75         glBindTexture(target, id);
76         assert(glGetError() == GL_NO_ERROR);
77         glTexParameteri(target, GL_TEXTURE_WRAP_S, wrap);
78         glTexParameteri(target, GL_TEXTURE_WRAP_T, wrap);
79         glTexParameteri(target, GL_TEXTURE_WRAP_R, wrap);
80 }
81
82 void Texture::set_filtering(unsigned int filt)
83 {
84         unsigned int mag_filter;
85
86         if(!target) {
87                 return;
88         }
89
90         switch(filt) {
91         case GL_LINEAR_MIPMAP_NEAREST:
92         case GL_LINEAR_MIPMAP_LINEAR:
93                 mag_filter = GL_LINEAR;
94                 break;
95
96         case GL_NEAREST_MIPMAP_NEAREST:
97         case GL_NEAREST_MIPMAP_LINEAR:
98                 mag_filter = GL_NEAREST;
99                 break;
100
101         default:
102                 mag_filter = filt;
103         }
104
105         set_filtering(filt, mag_filter);
106 }
107
108 void Texture::set_filtering(unsigned int min_filt, unsigned int mag_filt)
109 {
110         glBindTexture(target, id);
111         assert(glGetError() == GL_NO_ERROR);
112         glTexParameteri(target, GL_TEXTURE_MIN_FILTER, min_filt);
113         glTexParameteri(target, GL_TEXTURE_MAG_FILTER, mag_filt);
114 }
115
116 unsigned int Texture::get_format() const
117 {
118         return texfmt;
119 }
120
121 int Texture::get_size(int dim) const
122 {
123         if(dim < 0 || dim >= 3) {
124                 return 0;
125         }
126         return sz[dim];
127 }
128
129 unsigned int Texture::get_id() const
130 {
131         return id;
132 }
133
134 TextureType Texture::get_type() const
135 {
136         return target_to_type(target);
137 }
138
139 void Texture::bind(int tex_unit) const
140 {
141         glActiveTexture(GL_TEXTURE0 + tex_unit);
142         glBindTexture(target, id);
143         assert(glGetError() == GL_NO_ERROR);
144         glActiveTexture(GL_TEXTURE0);
145
146         cur_target[tex_unit] = target;
147 }
148
149
150 void Texture::create(int xsz, int ysz, TextureType textype, unsigned int ifmt)
151 {
152         if(textype == TEX_CUBE && xsz != ysz) {
153                 error_log("trying to create cubemap with different width and height (%dx%d)\n", xsz, ysz);
154                 return;
155         }
156
157         int fmt = glfmt_from_ifmt(ifmt);
158         int type = gltype_from_ifmt(ifmt);
159
160         target = type_to_target(textype);
161
162         glBindTexture(target, id);
163         assert(glGetError() == GL_NO_ERROR);
164         glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
165         glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
166
167         switch(type) {
168         case TEX_2D:
169                 glTexImage2D(GL_TEXTURE_2D, 0, glifmt_from_ifmt(ifmt), xsz, ysz, 0, fmt, type, 0);
170                 break;
171
172         case TEX_CUBE:
173                 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
174                 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
175                 glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
176                 for(int i=0; i<6; i++) {
177                         glTexImage2D(cube_faces[i], 0, ifmt, xsz, ysz, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);
178                 }
179                 break;
180         }
181
182         sz[0] = xsz;
183         sz[1] = ysz;
184         texfmt = ifmt;
185 }
186
187 #define DEF_IMAGE_SIZE  64
188 void Texture::create_default(TextureType type)
189 {
190         if(!default_img) {
191                 default_img = new Image;
192                 default_img->create(DEF_IMAGE_SIZE, DEF_IMAGE_SIZE, Image::FMT_RGBA);
193
194                 unsigned char *pixels = (unsigned char*)default_img->get_pixels();
195                 for(int i=0; i<DEF_IMAGE_SIZE; i++) {
196                         for(int j=0; j<DEF_IMAGE_SIZE; j++) {
197                                 bool chess = ((i >> 3) & 1) == ((j >> 3) & 1);
198                                 pixels[0] = chess ? 255 : 32;
199                                 pixels[1] = 64;
200                                 pixels[2] = chess ? 32 : 255;
201                                 pixels[3] = 255;
202                                 pixels += 4;
203                         }
204                 }
205         }
206
207         switch(type) {
208         case TEX_2D:
209                 set_image(*default_img);
210                 break;
211
212         case TEX_CUBE:
213                 for(int i=0; i<6; i++) {
214                         set_image(*default_img, i);
215                 }
216                 break;
217         }
218 }
219
220 void Texture::set_image(const Image &img, int idx)
221 {
222         if(idx >= 0 && idx < 6) {
223                 set_image_cube(img, idx);
224         } else {
225                 if(!set_image_cube(img)) {
226                         set_image_2d(img);
227                 }
228         }
229 }
230
231 void Texture::set_image_2d(const Image &img)
232 {
233         texfmt = glifmt_from_imgfmt(img.get_format());
234         unsigned int fmt = glfmt_from_ifmt(texfmt);
235         unsigned int type = gltype_from_ifmt(texfmt);
236
237         sz[0] = img.get_width();
238         sz[1] = img.get_height();
239
240         target = GL_TEXTURE_2D;
241         glBindTexture(target, id);
242         assert(glGetError() == GL_NO_ERROR);
243         glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
244         glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
245         glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_REPEAT);
246         glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_REPEAT);
247
248         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
249
250 #ifdef __GLEW_H__
251         if(GLEW_SGIS_generate_mipmap) {
252                 glTexParameteri(target, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
253 #endif
254                 glTexImage2D(target, 0, texfmt, sz[0], sz[1], 0, fmt, type, img.get_pixels());
255 #ifdef __GLEW_H__
256         } else {
257                 gluBuild2DMipmaps(target, texfmt, sz[0], sz[1], fmt, type, img.get_pixels());
258         }
259 #endif
260
261 #ifdef GL_ES_VERSION_2_0
262         glGenerateMipmap(target);
263 #endif
264 }
265
266 bool Texture::set_image_cube(const Image &img, int idx)
267 {
268         unsigned int err;
269         if(idx < 0 || idx >= 6) {
270                 return false;
271         }
272
273         texfmt = glifmt_from_imgfmt(img.get_format());
274         unsigned int fmt = glfmt_from_ifmt(texfmt);
275         unsigned int type = gltype_from_ifmt(texfmt);
276
277         sz[0] = img.get_width();
278         sz[1] = img.get_height();
279
280         target = GL_TEXTURE_CUBE_MAP;
281         glBindTexture(target, id);
282         if((err = glGetError()) == GL_INVALID_OPERATION) {
283                 return false;   // probably not a cubemap
284         }
285         assert(err == GL_NO_ERROR);
286         glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
287         glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
288         glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
289         glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
290         glTexParameteri(target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
291
292         glTexImage2D(cube_faces[idx], 0, texfmt, sz[0], sz[1], 0, fmt, type, img.get_pixels());
293         return true;
294 }
295
296 bool Texture::set_image_cube(const Image &img)
297 {
298         static const float one_third = 1.0 / 3.0;
299         static const float two_thirds = 2.0 / 3.0;
300         static const float hcross[2][6] = {
301                 {0.5, 0.0, 0.25, 0.25, 0.25, 0.75}, {one_third, one_third, 0.0, two_thirds, one_third, one_third} };
302         static const float vcross[2][6] = {
303                 {two_thirds, 0.0, one_third, one_third, one_third, one_third}, {0.25, 0.25, 0.0, 0.5, 0.25, 0.75} };
304         static const float hsix[2][6] = {
305                 {0.0, 0.0, one_third, one_third, two_thirds, two_thirds}, {0.0, 0.5, 0.0, 0.5, 0.0, 0.5} };
306
307         int xsz = img.get_width();
308         int ysz = img.get_height();
309
310         if((xsz << 8) / 4 == (ysz << 8) / 3) {
311                 // horizontal cross, assume the vertical bit is center-left
312                 return set_cube_multi(img, hcross[0], hcross[1], xsz / 4);
313         }
314         if((xsz << 8) / 3 == (ysz << 8) / 4) {
315                 // vertical cross, assume the horizontal bit is center-top (180-rotated image 5)
316                 return set_cube_multi(img, vcross[0], vcross[1], ysz / 4, (1 << 5));
317         }
318         if((xsz << 8) / 3 == (ysz << 8) / 2) {
319                 // horizontal sixpack
320                 return set_cube_multi(img, hsix[0], hsix[1], ysz / 2);
321         }
322
323         return false;
324 }
325
326
327 bool Texture::load(const char *fname)
328 {
329         Image img;
330         if(!img.load(fname)) {
331                 error_log("failed to load 2D texture: %s\n", fname);
332                 return false;
333         }
334         set_image(img);
335
336         info_log("loaded 2D texture: %s\n", fname);
337         return true;
338 }
339
340 bool Texture::load_cube(const char *fname)
341 {
342         Image img;
343         if(!img.load(fname)) {
344                 return false;
345         }
346         return set_image_cube(img);
347 }
348
349 bool Texture::set_cube_multi(const Image &img, const float *xoffsets, const float *yoffsets, float sz,
350                 unsigned int rotmask)
351 {
352         for(int i=0; i<6; i++) {
353                 Image face;
354
355                 int xoffs = xoffsets[i] * img.get_width();
356                 int yoffs = yoffsets[i] * img.get_height();
357
358                 if(!face.set_pixels(sz, sz, img.get_pixels(), xoffs, yoffs, img.get_width(), img.get_format())) {
359                         return false;
360                 }
361
362                 if(rotmask & (1 << i)) {
363                         face.rotate_180();
364                 }
365                 set_image_cube(face, i);
366         }
367         return true;
368 }
369
370 static int glifmt_from_ifmt(unsigned int ifmt)
371 {
372 #ifdef GL_ES_VERSION_2_0
373         switch(ifmt) {
374         case GL_LUMINANCE16F_ARB:
375         case GL_LUMINANCE32F_ARB:
376                 ifmt = GL_LUMINANCE;
377                 break;
378
379         case GL_RGB16F:
380         case GL_RGB32F:
381                 ifmt = GL_RGB;
382                 break;
383
384         case GL_RGBA16F:
385         case GL_RGBA32F:
386                 ifmt = GL_RGBA;
387                 break;
388
389         default:
390                 break;
391         }
392 #endif
393         return ifmt;    // by default just pass it through...
394 }
395
396 static int glfmt_from_ifmt(unsigned int ifmt)
397 {
398         switch(ifmt) {
399         case GL_LUMINANCE16F_ARB:
400         case GL_LUMINANCE32F_ARB:
401         case GL_SLUMINANCE:
402                 return GL_LUMINANCE;
403
404         case GL_RGB16F:
405         case GL_RGB32F:
406         case GL_SRGB:
407                 return GL_RGB;
408
409         case GL_RGBA16F:
410         case GL_RGBA32F:
411         case GL_SRGB_ALPHA:
412                 return GL_RGBA;
413
414         default:
415                 break;
416         }
417         return ifmt;
418 }
419
420 static int gltype_from_ifmt(unsigned int ifmt)
421 {
422         switch(ifmt) {
423         case GL_RGB16F:
424         case GL_RGBA16F:
425         case GL_LUMINANCE16F_ARB:
426 #ifdef GL_ES_VERSION_2_0
427                 return GL_HALF_FLOAT_OES;
428 #endif
429         case GL_RGB32F:
430         case GL_RGBA32F:
431         case GL_LUMINANCE32F_ARB:
432                 return GL_FLOAT;
433
434         default:
435                 break;
436         }
437         return GL_UNSIGNED_BYTE;
438 }
439
440 static int glifmt_from_imgfmt(Image::Format fmt)
441 {
442         switch(fmt) {
443         case Image::FMT_GREY:
444                 return GL_SLUMINANCE;
445         case Image::FMT_GREY_FLOAT:
446                 return GL_LUMINANCE16F_ARB;
447         case Image::FMT_RGB:
448                 return GL_SRGB;
449         case Image::FMT_RGB_FLOAT:
450                 return GL_RGB16F;
451         case Image::FMT_RGBA:
452                 return GL_SRGB_ALPHA;
453         case Image::FMT_RGBA_FLOAT:
454                 return GL_RGBA16F;
455         default:
456                 break;
457         }
458         return 0;
459 }
460
461 static unsigned int type_to_target(TextureType type)
462 {
463         return type == TEX_CUBE ? GL_TEXTURE_CUBE_MAP : GL_TEXTURE_2D;
464 }
465
466 static TextureType target_to_type(unsigned int targ)
467 {
468         return targ == GL_TEXTURE_CUBE_MAP ? TEX_CUBE : TEX_2D;
469 }
470
471 // ---- TextureSet ----
472 TextureSet::TextureSet()
473         : DataSet<Texture*>(create_tex, load_tex, done_tex, free_tex)
474 {
475 }
476
477 Texture *TextureSet::get_texture(const char *name, TextureType type, const DataMap *dmap) const
478 {
479         char *fname;
480         int nsize = dmap ? dmap->path_size(name) : 0;
481         if(nsize) {
482                 fname = (char*)alloca(nsize);
483                 dmap->lookup(name, fname, nsize);
484                 //debug_log("texture lookup: %s -> %s\n", name, fname);
485         } else {
486                 fname = (char*)name;
487                 //debug_log("texture lookup failed, using: %s\n", fname);
488         }
489
490         std::map<std::string, Texture*>::const_iterator iter = data.find(fname);
491         if(iter != data.end()) {
492                 return iter->second;
493         }
494
495         Texture *res = create();
496         data[fname] = res;
497         res->create_default(type);
498         resman_lookup(rman, fname, res);
499         return res;
500 }
501
502 // static callbacks
503
504 Texture *TextureSet::create_tex()
505 {
506         return new Texture;
507 }
508
509 bool TextureSet::load_tex(Texture *tex, const char *fname)
510 {
511         Image *img = new Image;
512         img->name = fname;
513         if(!img->load(fname)) {
514                 delete img;
515                 return false;
516         }
517
518         delete tex->img;
519         tex->img = img;
520
521         return true;
522 }
523
524 bool TextureSet::done_tex(Texture *tex)
525 {
526         //debug_log("TextureSet::done_tex [%s]\n", tex->img->name.c_str());
527         if(!tex->img) {
528                 return false;
529         }
530
531         tex->set_image(*tex->img);
532         return true;
533 }
534
535 void TextureSet::free_tex(Texture *tex)
536 {
537         delete tex;
538 }