git.mutantstargoat.com Git - antikythera/blob - src/texture.cc

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