gl_textures.c

   1
   2 #include "quakedef.h"
   3 #include "image.h"
   4 #include "jpeg.h"
   5 #include "image_png.h"
   6
   7 cvar_t gl_max_size = {CVAR_SAVE, "gl_max_size", "2048", "maximum allowed texture size, can be used to reduce video memory usage, limited by hardware capabilities (typically 2048, 4096, or 8192)"};
   8 cvar_t gl_max_lightmapsize = {CVAR_SAVE, "gl_max_lightmapsize", "1024", "maximum allowed texture size for lightmap textures, use larger values to improve rendering speed, as long as there is enough video memory available (setting it too high for the hardware will cause very bad performance)"};
   9 cvar_t gl_picmip = {CVAR_SAVE, "gl_picmip", "0", "reduces resolution of textures by powers of 2, for example 1 will halve width/height, reducing texture memory usage by 75%"};
  10 cvar_t r_lerpimages = {CVAR_SAVE, "r_lerpimages", "1", "bilinear filters images when scaling them up to power of 2 size (mode 1), looks better than glquake (mode 0)"};
  11 cvar_t r_precachetextures = {CVAR_SAVE, "r_precachetextures", "1", "0 = never upload textures until used, 1 = upload most textures before use (exceptions: rarely used skin colormap layers), 2 = upload all textures before use (can increase texture memory usage significantly)"};
  12 cvar_t gl_texture_anisotropy = {CVAR_SAVE, "gl_texture_anisotropy", "1", "anisotropic filtering quality (if supported by hardware), 1 sample (no anisotropy) and 8 sample (8 tap anisotropy) are recommended values"};
  13 cvar_t gl_texturecompression = {CVAR_SAVE, "gl_texturecompression", "0", "whether to compress textures, a value of 0 disables compression (even if the individual cvars are 1), 1 enables fast (low quality) compression at startup, 2 enables slow (high quality) compression at startup"};
  14 cvar_t gl_texturecompression_color = {CVAR_SAVE, "gl_texturecompression_color", "1", "whether to compress colormap (diffuse) textures"};
  15 cvar_t gl_texturecompression_normal = {CVAR_SAVE, "gl_texturecompression_normal", "0", "whether to compress normalmap (normalmap) textures"};
  16 cvar_t gl_texturecompression_gloss = {CVAR_SAVE, "gl_texturecompression_gloss", "1", "whether to compress glossmap (specular) textures"};
  17 cvar_t gl_texturecompression_glow = {CVAR_SAVE, "gl_texturecompression_glow", "1", "whether to compress glowmap (luma) textures"};
  18 cvar_t gl_texturecompression_2d = {CVAR_SAVE, "gl_texturecompression_2d", "0", "whether to compress 2d (hud/menu) textures other than the font"};
  19 cvar_t gl_texturecompression_q3bsplightmaps = {CVAR_SAVE, "gl_texturecompression_q3bsplightmaps", "0", "whether to compress lightmaps in q3bsp format levels"};
  20 cvar_t gl_texturecompression_q3bspdeluxemaps = {CVAR_SAVE, "gl_texturecompression_q3bspdeluxemaps", "0", "whether to compress deluxemaps in q3bsp format levels (only levels compiled with q3map2 -deluxe have these)"};
  21 cvar_t gl_texturecompression_sky = {CVAR_SAVE, "gl_texturecompression_sky", "0", "whether to compress sky textures"};
  22 cvar_t gl_texturecompression_lightcubemaps = {CVAR_SAVE, "gl_texturecompression_lightcubemaps", "1", "whether to compress light cubemaps (spotlights and other light projection images)"};
  23
  24 int             gl_filter_min = GL_LINEAR_MIPMAP_LINEAR;
  25 int             gl_filter_mag = GL_LINEAR;
  26
  27
  28 static mempool_t *texturemempool;
  29
  30 // note: this must not conflict with TEXF_ flags in r_textures.h
  31 // cleared when a texture is uploaded
  32 #define GLTEXF_UPLOAD           0x00010000
  33 // bitmask for mismatch checking
  34 #define GLTEXF_IMPORTANTBITS (0)
  35 // set when image is uploaded and freed
  36 #define GLTEXF_DESTROYED        0x00040000
  37 // dynamic texture (treat texnum == 0 differently)
  38 #define GLTEXF_DYNAMIC          0x00080000
  39
  40 typedef struct textypeinfo_s
  41 {
  42         textype_t textype;
  43         int inputbytesperpixel;
  44         int internalbytesperpixel;
  45         float glinternalbytesperpixel;
  46         int glformat;
  47         int glinternalformat;
  48         int gltype;
  49 }
  50 textypeinfo_t;
  51
  52 static textypeinfo_t textype_palette                = {TEXTYPE_PALETTE, 1, 4, 4.0f, GL_BGRA   , 3, GL_UNSIGNED_BYTE};
  53 static textypeinfo_t textype_palette_alpha          = {TEXTYPE_PALETTE, 1, 4, 4.0f, GL_BGRA   , 4, GL_UNSIGNED_BYTE};
  54 static textypeinfo_t textype_palette_compress       = {TEXTYPE_PALETTE, 1, 4, 0.5f, GL_BGRA   , GL_COMPRESSED_RGB_ARB, GL_UNSIGNED_BYTE};
  55 static textypeinfo_t textype_palette_alpha_compress = {TEXTYPE_PALETTE, 1, 4, 1.0f, GL_BGRA   , GL_COMPRESSED_RGBA_ARB, GL_UNSIGNED_BYTE};
  56 static textypeinfo_t textype_rgba                   = {TEXTYPE_RGBA   , 4, 4, 4.0f, GL_RGBA   , 3, GL_UNSIGNED_BYTE};
  57 static textypeinfo_t textype_rgba_alpha             = {TEXTYPE_RGBA   , 4, 4, 4.0f, GL_RGBA   , 4, GL_UNSIGNED_BYTE};
  58 static textypeinfo_t textype_rgba_compress          = {TEXTYPE_RGBA   , 4, 4, 0.5f, GL_RGBA   , GL_COMPRESSED_RGB_ARB, GL_UNSIGNED_BYTE};
  59 static textypeinfo_t textype_rgba_alpha_compress    = {TEXTYPE_RGBA   , 4, 4, 1.0f, GL_RGBA   , GL_COMPRESSED_RGBA_ARB, GL_UNSIGNED_BYTE};
  60 static textypeinfo_t textype_bgra                   = {TEXTYPE_BGRA   , 4, 4, 4.0f, GL_BGRA   , 3, GL_UNSIGNED_BYTE};
  61 static textypeinfo_t textype_bgra_alpha             = {TEXTYPE_BGRA   , 4, 4, 4.0f, GL_BGRA   , 4, GL_UNSIGNED_BYTE};
  62 static textypeinfo_t textype_bgra_compress          = {TEXTYPE_BGRA   , 4, 4, 0.5f, GL_BGRA   , GL_COMPRESSED_RGB_ARB, GL_UNSIGNED_BYTE};
  63 static textypeinfo_t textype_bgra_alpha_compress    = {TEXTYPE_BGRA   , 4, 4, 1.0f, GL_BGRA   , GL_COMPRESSED_RGBA_ARB, GL_UNSIGNED_BYTE};
  64 static textypeinfo_t textype_shadowmap16            = {TEXTYPE_SHADOWMAP,2,2, 2.0f, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16_ARB, GL_UNSIGNED_SHORT};
  65 static textypeinfo_t textype_shadowmap24            = {TEXTYPE_SHADOWMAP,4,4, 4.0f, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT24_ARB, GL_UNSIGNED_INT};
  66
  67 typedef enum gltexturetype_e
  68 {
  69         GLTEXTURETYPE_2D,
  70         GLTEXTURETYPE_3D,
  71         GLTEXTURETYPE_CUBEMAP,
  72         GLTEXTURETYPE_RECTANGLE,
  73         GLTEXTURETYPE_TOTAL
  74 }
  75 gltexturetype_t;
  76
  77 static int gltexturetypeenums[GLTEXTURETYPE_TOTAL] = {GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_RECTANGLE_ARB};
  78 static int gltexturetypebindingenums[GLTEXTURETYPE_TOTAL] = {GL_TEXTURE_BINDING_2D, GL_TEXTURE_BINDING_3D, GL_TEXTURE_BINDING_CUBE_MAP_ARB, GL_TEXTURE_BINDING_RECTANGLE_ARB};
  79 static int gltexturetypedimensions[GLTEXTURETYPE_TOTAL] = {2, 3, 2, 2};
  80 static int cubemapside[6] =
  81 {
  82         GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB,
  83         GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB,
  84         GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB,
  85         GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB,
  86         GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB,
  87         GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB
  88 };
  89
  90 typedef struct gltexture_s
  91 {
  92         // this field is exposed to the R_GetTexture macro, for speed reasons
  93         // (must be identical in rtexture_t)
  94         int texnum; // GL texture slot number
  95
  96         // dynamic texture stuff [11/22/2007 Black]
  97         // used to hold the texture number of dirty textures
  98         int dirtytexnum;
  99         updatecallback_t updatecallback;
 100         void *updatacallback_data;
 101         // --- [11/22/2007 Black]
 102
 103         // pointer to texturepool (check this to see if the texture is allocated)
 104         struct gltexturepool_s *pool;
 105         // pointer to next texture in texturepool chain
 106         struct gltexture_s *chain;
 107         // name of the texture (this might be removed someday), no duplicates
 108         char identifier[MAX_QPATH + 32];
 109         // original data size in *inputtexels
 110         int inputwidth, inputheight, inputdepth;
 111         // copy of the original texture(s) supplied to the upload function, for
 112         // delayed uploads (non-precached)
 113         unsigned char *inputtexels;
 114         // original data size in *inputtexels
 115         int inputdatasize;
 116         // flags supplied to the LoadTexture function
 117         // (might be altered to remove TEXF_ALPHA), and GLTEXF_ private flags
 118         int flags;
 119         // pointer to one of the textype_ structs
 120         textypeinfo_t *textype;
 121         // one of the GLTEXTURETYPE_ values
 122         int texturetype;
 123         // palette if the texture is TEXTYPE_PALETTE
 124         const unsigned int *palette;
 125         // actual stored texture size after gl_picmip and gl_max_size are applied
 126         // (power of 2 if vid.support.arb_texture_non_power_of_two is not supported)
 127         int tilewidth, tileheight, tiledepth;
 128         // 1 or 6 depending on texturetype
 129         int sides;
 130         // bytes per pixel
 131         int bytesperpixel;
 132         // GL_RGB or GL_RGBA or GL_DEPTH_COMPONENT
 133         int glformat;
 134         // 3 or 4
 135         int glinternalformat;
 136         // GL_UNSIGNED_BYTE or GL_UNSIGNED_INT or GL_UNSIGNED_SHORT or GL_FLOAT
 137         int gltype;
 138 }
 139 gltexture_t;
 140
 141 #define TEXTUREPOOL_SENTINEL 0xC0DEDBAD
 142
 143 typedef struct gltexturepool_s
 144 {
 145         unsigned int sentinel;
 146         struct gltexture_s *gltchain;
 147         struct gltexturepool_s *next;
 148 }
 149 gltexturepool_t;
 150
 151 static gltexturepool_t *gltexturepoolchain = NULL;
 152
 153 static unsigned char *resizebuffer = NULL, *colorconvertbuffer;
 154 static int resizebuffersize = 0;
 155 static const unsigned char *texturebuffer;
 156 static int texturebuffersize = 0;
 157
 158 static textypeinfo_t *R_GetTexTypeInfo(textype_t textype, int flags)
 159 {
 160         if ((flags & TEXF_COMPRESS) && gl_texturecompression.integer >= 1 && vid.support.arb_texture_compression)
 161         {
 162                 if (flags & TEXF_ALPHA)
 163                 {
 164                         switch(textype)
 165                         {
 166                         case TEXTYPE_PALETTE:
 167                                 return &textype_palette_alpha_compress;
 168                         case TEXTYPE_RGBA:
 169                                 return &textype_rgba_alpha_compress;
 170                         case TEXTYPE_BGRA:
 171                                 return &textype_bgra_alpha_compress;
 172                         default:
 173                                 Host_Error("R_GetTexTypeInfo: unknown texture format");
 174                                 return NULL;
 175                         }
 176                 }
 177                 else
 178                 {
 179                         switch(textype)
 180                         {
 181                         case TEXTYPE_PALETTE:
 182                                 return &textype_palette_compress;
 183                         case TEXTYPE_RGBA:
 184                                 return &textype_rgba_compress;
 185                         case TEXTYPE_BGRA:
 186                                 return &textype_bgra_compress;
 187                         default:
 188                                 Host_Error("R_GetTexTypeInfo: unknown texture format");
 189                                 return NULL;
 190                         }
 191                 }
 192         }
 193         else
 194         {
 195                 if (flags & TEXF_ALPHA)
 196                 {
 197                         switch(textype)
 198                         {
 199                         case TEXTYPE_PALETTE:
 200                                 return &textype_palette_alpha;
 201                         case TEXTYPE_RGBA:
 202                                 return &textype_rgba_alpha;
 203                         case TEXTYPE_BGRA:
 204                                 return &textype_bgra_alpha;
 205                         default:
 206                                 Host_Error("R_GetTexTypeInfo: unknown texture format");
 207                                 return NULL;
 208                         }
 209                 }
 210                 else
 211                 {
 212                         switch(textype)
 213                         {
 214                         case TEXTYPE_PALETTE:
 215                                 return &textype_palette;
 216                         case TEXTYPE_RGBA:
 217                                 return &textype_rgba;
 218                         case TEXTYPE_BGRA:
 219                                 return &textype_bgra;
 220                         case TEXTYPE_SHADOWMAP:
 221                                 return (flags & TEXF_LOWPRECISION) ? &textype_shadowmap16 : &textype_shadowmap24;
 222                         default:
 223                                 Host_Error("R_GetTexTypeInfo: unknown texture format");
 224                                 return NULL;
 225                         }
 226                 }
 227         }
 228         return NULL; // this line only to hush compiler warnings
 229 }
 230
 231 // dynamic texture code [11/22/2007 Black]
 232 void R_MarkDirtyTexture(rtexture_t *rt) {
 233         gltexture_t *glt = (gltexture_t*) rt;
 234         if( !glt ) {
 235                 return;
 236         }
 237
 238         // dont do anything if the texture is already dirty (and make sure this *is* a dynamic texture after all!)
 239         if( !glt->dirtytexnum && glt->flags & GLTEXF_DYNAMIC ) {
 240                 glt->dirtytexnum = glt->texnum;
 241                 // mark it as dirty, so R_RealGetTexture gets called
 242                 glt->texnum = 0;
 243         }
 244 }
 245
 246 void R_MakeTextureDynamic(rtexture_t *rt, updatecallback_t updatecallback, void *data) {
 247         gltexture_t *glt = (gltexture_t*) rt;
 248         if( !glt ) {
 249                 return;
 250         }
 251
 252         glt->flags |= GLTEXF_DYNAMIC;
 253         glt->updatecallback = updatecallback;
 254         glt->updatacallback_data = data;
 255         glt->dirtytexnum = 0;
 256 }
 257
 258 static void R_UpdateDynamicTexture(gltexture_t *glt) {
 259         glt->texnum = glt->dirtytexnum;
 260         // reset dirtytexnum again (not dirty anymore)
 261         glt->dirtytexnum = 0;
 262         // TODO: now assert that t->texnum != 0 ?
 263         if( glt->updatecallback ) {
 264                 glt->updatecallback( (rtexture_t*) glt, glt->updatacallback_data );
 265         }
 266 }
 267
 268 void R_PurgeTexture(rtexture_t *rt)
 269 {
 270         if(rt && !(((gltexture_t*) rt)->flags & TEXF_PERSISTENT)) {
 271                 R_FreeTexture(rt);
 272         }
 273 }
 274
 275 void R_FreeTexture(rtexture_t *rt)
 276 {
 277         gltexture_t *glt, **gltpointer;
 278
 279         glt = (gltexture_t *)rt;
 280         if (glt == NULL)
 281                 Host_Error("R_FreeTexture: texture == NULL");
 282
 283         for (gltpointer = &glt->pool->gltchain;*gltpointer && *gltpointer != glt;gltpointer = &(*gltpointer)->chain);
 284         if (*gltpointer == glt)
 285                 *gltpointer = glt->chain;
 286         else
 287                 Host_Error("R_FreeTexture: texture \"%s\" not linked in pool", glt->identifier);
 288
 289         if (!(glt->flags & GLTEXF_UPLOAD))
 290         {
 291                 CHECKGLERROR
 292                 qglDeleteTextures(1, (GLuint *)&glt->texnum);CHECKGLERROR
 293         }
 294
 295         if (glt->inputtexels)
 296                 Mem_Free(glt->inputtexels);
 297         Mem_Free(glt);
 298 }
 299
 300 rtexturepool_t *R_AllocTexturePool(void)
 301 {
 302         gltexturepool_t *pool;
 303         if (texturemempool == NULL)
 304                 return NULL;
 305         pool = (gltexturepool_t *)Mem_Alloc(texturemempool, sizeof(gltexturepool_t));
 306         if (pool == NULL)
 307                 return NULL;
 308         pool->next = gltexturepoolchain;
 309         gltexturepoolchain = pool;
 310         pool->sentinel = TEXTUREPOOL_SENTINEL;
 311         return (rtexturepool_t *)pool;
 312 }
 313
 314 void R_FreeTexturePool(rtexturepool_t **rtexturepool)
 315 {
 316         gltexturepool_t *pool, **poolpointer;
 317         if (rtexturepool == NULL)
 318                 return;
 319         if (*rtexturepool == NULL)
 320                 return;
 321         pool = (gltexturepool_t *)(*rtexturepool);
 322         *rtexturepool = NULL;
 323         if (pool->sentinel != TEXTUREPOOL_SENTINEL)
 324                 Host_Error("R_FreeTexturePool: pool already freed");
 325         for (poolpointer = &gltexturepoolchain;*poolpointer && *poolpointer != pool;poolpointer = &(*poolpointer)->next);
 326         if (*poolpointer == pool)
 327                 *poolpointer = pool->next;
 328         else
 329                 Host_Error("R_FreeTexturePool: pool not linked");
 330         while (pool->gltchain)
 331                 R_FreeTexture((rtexture_t *)pool->gltchain);
 332         Mem_Free(pool);
 333 }
 334
 335
 336 typedef struct glmode_s
 337 {
 338         char *name;
 339         int minification, magnification;
 340 }
 341 glmode_t;
 342
 343 static glmode_t modes[6] =
 344 {
 345         {"GL_NEAREST", GL_NEAREST, GL_NEAREST},
 346         {"GL_LINEAR", GL_LINEAR, GL_LINEAR},
 347         {"GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST},
 348         {"GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR},
 349         {"GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST},
 350         {"GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR}
 351 };
 352
 353 static void GL_TextureMode_f (void)
 354 {
 355         int i;
 356         GLint oldbindtexnum;
 357         gltexture_t *glt;
 358         gltexturepool_t *pool;
 359
 360         if (Cmd_Argc() == 1)
 361         {
 362                 for (i = 0;i < 6;i++)
 363                 {
 364                         if (gl_filter_min == modes[i].minification)
 365                         {
 366                                 Con_Printf("%s\n", modes[i].name);
 367                                 return;
 368                         }
 369                 }
 370                 Con_Print("current filter is unknown???\n");
 371                 return;
 372         }
 373
 374         for (i = 0;i < 6;i++)
 375                 if (!strcasecmp (modes[i].name, Cmd_Argv(1) ) )
 376                         break;
 377         if (i == 6)
 378         {
 379                 Con_Print("bad filter name\n");
 380                 return;
 381         }
 382
 383         gl_filter_min = modes[i].minification;
 384         gl_filter_mag = modes[i].magnification;
 385
 386         // change all the existing mipmap texture objects
 387         // FIXME: force renderer(/client/something?) restart instead?
 388         CHECKGLERROR
 389         for (pool = gltexturepoolchain;pool;pool = pool->next)
 390         {
 391                 for (glt = pool->gltchain;glt;glt = glt->chain)
 392                 {
 393                         // only update already uploaded images
 394                         if (!(glt->flags & (GLTEXF_UPLOAD | TEXF_FORCENEAREST | TEXF_FORCELINEAR)))
 395                         {
 396                                 qglGetIntegerv(gltexturetypebindingenums[glt->texturetype], &oldbindtexnum);CHECKGLERROR
 397                                 qglBindTexture(gltexturetypeenums[glt->texturetype], glt->texnum);CHECKGLERROR
 398                                 if (glt->flags & TEXF_MIPMAP)
 399                                 {
 400                                         qglTexParameteri(gltexturetypeenums[glt->texturetype], GL_TEXTURE_MIN_FILTER, gl_filter_min);CHECKGLERROR
 401                                 }
 402                                 else
 403                                 {
 404                                         qglTexParameteri(gltexturetypeenums[glt->texturetype], GL_TEXTURE_MIN_FILTER, gl_filter_mag);CHECKGLERROR
 405                                 }
 406                                 qglTexParameteri(gltexturetypeenums[glt->texturetype], GL_TEXTURE_MAG_FILTER, gl_filter_mag);CHECKGLERROR
 407                                 qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR
 408                         }
 409                 }
 410         }
 411 }
 412
 413 static void GL_Texture_CalcImageSize(int texturetype, int flags, int inwidth, int inheight, int indepth, int *outwidth, int *outheight, int *outdepth)
 414 {
 415         int picmip = 0, maxsize = 0, width2 = 1, height2 = 1, depth2 = 1;
 416
 417         switch (texturetype)
 418         {
 419         default:
 420         case GLTEXTURETYPE_2D:
 421                 maxsize = vid.maxtexturesize_2d;
 422                 if (flags & TEXF_PICMIP)
 423                 {
 424                         maxsize = bound(1, gl_max_size.integer, maxsize);
 425                         picmip = gl_picmip.integer;
 426                 }
 427                 break;
 428         case GLTEXTURETYPE_3D:
 429                 maxsize = vid.maxtexturesize_3d;
 430                 break;
 431         case GLTEXTURETYPE_CUBEMAP:
 432                 maxsize = vid.maxtexturesize_cubemap;
 433                 break;
 434         }
 435
 436         if (outwidth)
 437         {
 438                 if (vid.support.arb_texture_non_power_of_two)
 439                         width2 = min(inwidth >> picmip, maxsize);
 440                 else
 441                 {
 442                         for (width2 = 1;width2 < inwidth;width2 <<= 1);
 443                         for (width2 >>= picmip;width2 > maxsize;width2 >>= 1);
 444                 }
 445                 *outwidth = max(1, width2);
 446         }
 447         if (outheight)
 448         {
 449                 if (vid.support.arb_texture_non_power_of_two)
 450                         height2 = min(inheight >> picmip, maxsize);
 451                 else
 452                 {
 453                         for (height2 = 1;height2 < inheight;height2 <<= 1);
 454                         for (height2 >>= picmip;height2 > maxsize;height2 >>= 1);
 455                 }
 456                 *outheight = max(1, height2);
 457         }
 458         if (outdepth)
 459         {
 460                 if (vid.support.arb_texture_non_power_of_two)
 461                         depth2 = min(indepth >> picmip, maxsize);
 462                 else
 463                 {
 464                         for (depth2 = 1;depth2 < indepth;depth2 <<= 1);
 465                         for (depth2 >>= picmip;depth2 > maxsize;depth2 >>= 1);
 466                 }
 467                 *outdepth = max(1, depth2);
 468         }
 469 }
 470
 471
 472 static int R_CalcTexelDataSize (gltexture_t *glt)
 473 {
 474         int width2, height2, depth2, size;
 475
 476         GL_Texture_CalcImageSize(glt->texturetype, glt->flags, glt->inputwidth, glt->inputheight, glt->inputdepth, &width2, &height2, &depth2);
 477
 478         size = width2 * height2 * depth2;
 479
 480         if (glt->flags & TEXF_MIPMAP)
 481         {
 482                 while (width2 > 1 || height2 > 1 || depth2 > 1)
 483                 {
 484                         if (width2 > 1)
 485                                 width2 >>= 1;
 486                         if (height2 > 1)
 487                                 height2 >>= 1;
 488                         if (depth2 > 1)
 489                                 depth2 >>= 1;
 490                         size += width2 * height2 * depth2;
 491                 }
 492         }
 493
 494         return (int)(size * glt->textype->glinternalbytesperpixel) * glt->sides;
 495 }
 496
 497 void R_TextureStats_Print(qboolean printeach, qboolean printpool, qboolean printtotal)
 498 {
 499         int glsize;
 500         int isloaded;
 501         int pooltotal = 0, pooltotalt = 0, pooltotalp = 0, poolloaded = 0, poolloadedt = 0, poolloadedp = 0;
 502         int sumtotal = 0, sumtotalt = 0, sumtotalp = 0, sumloaded = 0, sumloadedt = 0, sumloadedp = 0;
 503         gltexture_t *glt;
 504         gltexturepool_t *pool;
 505         if (printeach)
 506                 Con_Print("glsize input loaded mip alpha name\n");
 507         for (pool = gltexturepoolchain;pool;pool = pool->next)
 508         {
 509                 pooltotal = 0;
 510                 pooltotalt = 0;
 511                 pooltotalp = 0;
 512                 poolloaded = 0;
 513                 poolloadedt = 0;
 514                 poolloadedp = 0;
 515                 for (glt = pool->gltchain;glt;glt = glt->chain)
 516                 {
 517                         glsize = R_CalcTexelDataSize(glt);
 518                         isloaded = !(glt->flags & GLTEXF_UPLOAD);
 519                         pooltotal++;
 520                         pooltotalt += glsize;
 521                         pooltotalp += glt->inputdatasize;
 522                         if (isloaded)
 523                         {
 524                                 poolloaded++;
 525                                 poolloadedt += glsize;
 526                                 poolloadedp += glt->inputdatasize;
 527                         }
 528                         if (printeach)
 529                                 Con_Printf("%c%4i%c%c%4i%c %s %s %s %s\n", isloaded ? '[' : ' ', (glsize + 1023) / 1024, isloaded ? ']' : ' ', glt->inputtexels ? '[' : ' ', (glt->inputdatasize + 1023) / 1024, glt->inputtexels ? ']' : ' ', isloaded ? "loaded" : "      ", (glt->flags & TEXF_MIPMAP) ? "mip" : "   ", (glt->flags & TEXF_ALPHA) ? "alpha" : "     ", glt->identifier);
 530                 }
 531                 if (printpool)
 532                         Con_Printf("texturepool %10p total: %i (%.3fMB, %.3fMB original), uploaded %i (%.3fMB, %.3fMB original), upload on demand %i (%.3fMB, %.3fMB original)\n", (void *)pool, pooltotal, pooltotalt / 1048576.0, pooltotalp / 1048576.0, poolloaded, poolloadedt / 1048576.0, poolloadedp / 1048576.0, pooltotal - poolloaded, (pooltotalt - poolloadedt) / 1048576.0, (pooltotalp - poolloadedp) / 1048576.0);
 533                 sumtotal += pooltotal;
 534                 sumtotalt += pooltotalt;
 535                 sumtotalp += pooltotalp;
 536                 sumloaded += poolloaded;
 537                 sumloadedt += poolloadedt;
 538                 sumloadedp += poolloadedp;
 539         }
 540         if (printtotal)
 541                 Con_Printf("textures total: %i (%.3fMB, %.3fMB original), uploaded %i (%.3fMB, %.3fMB original), upload on demand %i (%.3fMB, %.3fMB original)\n", sumtotal, sumtotalt / 1048576.0, sumtotalp / 1048576.0, sumloaded, sumloadedt / 1048576.0, sumloadedp / 1048576.0, sumtotal - sumloaded, (sumtotalt - sumloadedt) / 1048576.0, (sumtotalp - sumloadedp) / 1048576.0);
 542 }
 543
 544 static void R_TextureStats_f(void)
 545 {
 546         R_TextureStats_Print(true, true, true);
 547 }
 548
 549 static void r_textures_start(void)
 550 {
 551         // LordHavoc: allow any alignment
 552         CHECKGLERROR
 553         qglPixelStorei(GL_UNPACK_ALIGNMENT, 1);CHECKGLERROR
 554         qglPixelStorei(GL_PACK_ALIGNMENT, 1);CHECKGLERROR
 555
 556         texturemempool = Mem_AllocPool("texture management", 0, NULL);
 557
 558         // Disable JPEG screenshots if the DLL isn't loaded
 559         if (! JPEG_OpenLibrary ())
 560                 Cvar_SetValueQuick (&scr_screenshot_jpeg, 0);
 561         // TODO: support png screenshots?
 562         PNG_OpenLibrary ();
 563 }
 564
 565 static void r_textures_shutdown(void)
 566 {
 567         rtexturepool_t *temp;
 568
 569         JPEG_CloseLibrary ();
 570
 571         while(gltexturepoolchain)
 572         {
 573                 temp = (rtexturepool_t *) gltexturepoolchain;
 574                 R_FreeTexturePool(&temp);
 575         }
 576
 577         resizebuffersize = 0;
 578         texturebuffersize = 0;
 579         resizebuffer = NULL;
 580         colorconvertbuffer = NULL;
 581         texturebuffer = NULL;
 582         Mem_FreePool(&texturemempool);
 583 }
 584
 585 static void r_textures_newmap(void)
 586 {
 587 }
 588
 589 void R_Textures_Init (void)
 590 {
 591         Cmd_AddCommand("gl_texturemode", &GL_TextureMode_f, "set texture filtering mode (GL_NEAREST, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, etc)");
 592         Cmd_AddCommand("r_texturestats", R_TextureStats_f, "print information about all loaded textures and some statistics");
 593         Cvar_RegisterVariable (&gl_max_size);
 594         Cvar_RegisterVariable (&gl_picmip);
 595         Cvar_RegisterVariable (&gl_max_lightmapsize);
 596         Cvar_RegisterVariable (&r_lerpimages);
 597         Cvar_RegisterVariable (&r_precachetextures);
 598         Cvar_RegisterVariable (&gl_texture_anisotropy);
 599         Cvar_RegisterVariable (&gl_texturecompression);
 600         Cvar_RegisterVariable (&gl_texturecompression_color);
 601         Cvar_RegisterVariable (&gl_texturecompression_normal);
 602         Cvar_RegisterVariable (&gl_texturecompression_gloss);
 603         Cvar_RegisterVariable (&gl_texturecompression_glow);
 604         Cvar_RegisterVariable (&gl_texturecompression_2d);
 605         Cvar_RegisterVariable (&gl_texturecompression_q3bsplightmaps);
 606         Cvar_RegisterVariable (&gl_texturecompression_q3bspdeluxemaps);
 607         Cvar_RegisterVariable (&gl_texturecompression_sky);
 608         Cvar_RegisterVariable (&gl_texturecompression_lightcubemaps);
 609
 610         R_RegisterModule("R_Textures", r_textures_start, r_textures_shutdown, r_textures_newmap);
 611 }
 612
 613 void R_Textures_Frame (void)
 614 {
 615         static int old_aniso = 0;
 616
 617         // could do procedural texture animation here, if we keep track of which
 618         // textures were accessed this frame...
 619
 620         // free the resize buffers
 621         resizebuffersize = 0;
 622         if (resizebuffer)
 623         {
 624                 Mem_Free(resizebuffer);
 625                 resizebuffer = NULL;
 626         }
 627         if (colorconvertbuffer)
 628         {
 629                 Mem_Free(colorconvertbuffer);
 630                 colorconvertbuffer = NULL;
 631         }
 632
 633         if (old_aniso != gl_texture_anisotropy.integer)
 634         {
 635                 gltexture_t *glt;
 636                 gltexturepool_t *pool;
 637                 GLint oldbindtexnum;
 638
 639                 old_aniso = bound(1, gl_texture_anisotropy.integer, (int)vid.max_anisotropy);
 640
 641                 Cvar_SetValueQuick(&gl_texture_anisotropy, old_aniso);
 642
 643                 CHECKGLERROR
 644                 for (pool = gltexturepoolchain;pool;pool = pool->next)
 645                 {
 646                         for (glt = pool->gltchain;glt;glt = glt->chain)
 647                         {
 648                                 // only update already uploaded images
 649                                 if ((glt->flags & (GLTEXF_UPLOAD | TEXF_MIPMAP)) == TEXF_MIPMAP)
 650                                 {
 651                                         qglGetIntegerv(gltexturetypebindingenums[glt->texturetype], &oldbindtexnum);CHECKGLERROR
 652
 653                                         qglBindTexture(gltexturetypeenums[glt->texturetype], glt->texnum);CHECKGLERROR
 654                                         qglTexParameteri(gltexturetypeenums[glt->texturetype], GL_TEXTURE_MAX_ANISOTROPY_EXT, old_aniso);CHECKGLERROR
 655
 656                                         qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR
 657                                 }
 658                         }
 659                 }
 660         }
 661 }
 662
 663 void R_MakeResizeBufferBigger(int size)
 664 {
 665         if (resizebuffersize < size)
 666         {
 667                 resizebuffersize = size;
 668                 if (resizebuffer)
 669                         Mem_Free(resizebuffer);
 670                 if (colorconvertbuffer)
 671                         Mem_Free(colorconvertbuffer);
 672                 resizebuffer = (unsigned char *)Mem_Alloc(texturemempool, resizebuffersize);
 673                 colorconvertbuffer = (unsigned char *)Mem_Alloc(texturemempool, resizebuffersize);
 674                 if (!resizebuffer || !colorconvertbuffer)
 675                         Host_Error("R_Upload: out of memory");
 676         }
 677 }
 678
 679 static void GL_SetupTextureParameters(int flags, textype_t textype, int texturetype)
 680 {
 681         int textureenum = gltexturetypeenums[texturetype];
 682         int wrapmode = (flags & TEXF_CLAMP) ? GL_CLAMP_TO_EDGE : GL_REPEAT;
 683
 684         CHECKGLERROR
 685
 686         if (vid.support.ext_texture_filter_anisotropic && (flags & TEXF_MIPMAP))
 687         {
 688                 int aniso = bound(1, gl_texture_anisotropy.integer, (int)vid.max_anisotropy);
 689                 if (gl_texture_anisotropy.integer != aniso)
 690                         Cvar_SetValueQuick(&gl_texture_anisotropy, aniso);
 691                 qglTexParameteri(textureenum, GL_TEXTURE_MAX_ANISOTROPY_EXT, aniso);CHECKGLERROR
 692         }
 693         qglTexParameteri(textureenum, GL_TEXTURE_WRAP_S, wrapmode);CHECKGLERROR
 694         qglTexParameteri(textureenum, GL_TEXTURE_WRAP_T, wrapmode);CHECKGLERROR
 695         if (gltexturetypedimensions[texturetype] >= 3)
 696         {
 697                 qglTexParameteri(textureenum, GL_TEXTURE_WRAP_R, wrapmode);CHECKGLERROR
 698         }
 699
 700         CHECKGLERROR
 701         if (flags & TEXF_FORCENEAREST)
 702         {
 703                 if (flags & TEXF_MIPMAP)
 704                 {
 705                         qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);CHECKGLERROR
 706                 }
 707                 else
 708                 {
 709                         qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_NEAREST);CHECKGLERROR
 710                 }
 711                 qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, GL_NEAREST);CHECKGLERROR
 712         }
 713         else if (flags & TEXF_FORCELINEAR)
 714         {
 715                 if (flags & TEXF_MIPMAP)
 716                 {
 717                         if (gl_filter_min == GL_NEAREST_MIPMAP_LINEAR || gl_filter_min == GL_LINEAR_MIPMAP_LINEAR)
 718                         {
 719                                 qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);CHECKGLERROR
 720                         }
 721                         else
 722                         {
 723                                 qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);CHECKGLERROR
 724                         }
 725                 }
 726                 else
 727                 {
 728                         qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_LINEAR);CHECKGLERROR
 729                 }
 730                 qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, GL_LINEAR);CHECKGLERROR
 731         }
 732         else
 733         {
 734                 if (flags & TEXF_MIPMAP)
 735                 {
 736                         qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, gl_filter_min);CHECKGLERROR
 737                 }
 738                 else
 739                 {
 740                         qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, gl_filter_mag);CHECKGLERROR
 741                 }
 742                 qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, gl_filter_mag);CHECKGLERROR
 743         }
 744
 745         if (textype == TEXTYPE_SHADOWMAP)
 746         {
 747                 if (vid.support.arb_shadow)
 748                 {
 749                         if (flags & TEXF_COMPARE)
 750                         {
 751                                 qglTexParameteri(textureenum, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB);CHECKGLERROR
 752                         }
 753                         else
 754                         {
 755                                 qglTexParameteri(textureenum, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE);CHECKGLERROR
 756                         }
 757                         qglTexParameteri(textureenum, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);CHECKGLERROR
 758                 }
 759                 qglTexParameteri(textureenum, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE);CHECKGLERROR
 760         }
 761
 762         CHECKGLERROR
 763 }
 764
 765 static void R_Upload(gltexture_t *glt, const unsigned char *data, int fragx, int fragy, int fragz, int fragwidth, int fragheight, int fragdepth)
 766 {
 767         int i, mip, width, height, depth;
 768         GLint oldbindtexnum;
 769         const unsigned char *prevbuffer;
 770         prevbuffer = data;
 771
 772         CHECKGLERROR
 773
 774         // we need to restore the texture binding after finishing the upload
 775         qglGetIntegerv(gltexturetypebindingenums[glt->texturetype], &oldbindtexnum);CHECKGLERROR
 776         qglBindTexture(gltexturetypeenums[glt->texturetype], glt->texnum);CHECKGLERROR
 777
 778         // these are rounded up versions of the size to do better resampling
 779         if (vid.support.arb_texture_non_power_of_two || glt->texturetype == GLTEXTURETYPE_RECTANGLE)
 780         {
 781                 width = glt->inputwidth;
 782                 height = glt->inputheight;
 783                 depth = glt->inputdepth;
 784         }
 785         else
 786         {
 787                 for (width  = 1;width  < glt->inputwidth ;width  <<= 1);
 788                 for (height = 1;height < glt->inputheight;height <<= 1);
 789                 for (depth  = 1;depth  < glt->inputdepth ;depth  <<= 1);
 790         }
 791
 792         R_MakeResizeBufferBigger(width * height * depth * glt->sides * glt->bytesperpixel);
 793         R_MakeResizeBufferBigger(fragwidth * fragheight * fragdepth * glt->sides * glt->bytesperpixel);
 794
 795         if (prevbuffer == NULL)
 796         {
 797                 memset(resizebuffer, 0, fragwidth * fragheight * fragdepth * glt->bytesperpixel);
 798                 prevbuffer = resizebuffer;
 799         }
 800         else if (glt->textype->textype == TEXTYPE_PALETTE)
 801         {
 802                 // promote paletted to BGRA, so we only have to worry about BGRA in the rest of this code
 803                 Image_Copy8bitBGRA(prevbuffer, colorconvertbuffer, fragwidth * fragheight * fragdepth * glt->sides, glt->palette);
 804                 prevbuffer = colorconvertbuffer;
 805         }
 806
 807         if ((glt->flags & (TEXF_MIPMAP | TEXF_PICMIP | GLTEXF_UPLOAD)) == 0 && glt->inputwidth == glt->tilewidth && glt->inputheight == glt->tileheight && glt->inputdepth == glt->tiledepth)
 808         {
 809                 // update a portion of the image
 810                 switch(glt->texturetype)
 811                 {
 812                 case GLTEXTURETYPE_2D:
 813                         qglTexSubImage2D(GL_TEXTURE_2D, 0, fragx, fragy, fragwidth, fragheight, glt->glformat, glt->gltype, prevbuffer);CHECKGLERROR
 814                         break;
 815                 case GLTEXTURETYPE_3D:
 816                         qglTexSubImage3D(GL_TEXTURE_3D, 0, fragx, fragy, fragz, fragwidth, fragheight, fragdepth, glt->glformat, glt->gltype, prevbuffer);CHECKGLERROR
 817                         break;
 818                 default:
 819                         Host_Error("R_Upload: partial update of type other than 2D");
 820                         break;
 821                 }
 822         }
 823         else
 824         {
 825                 if (fragx || fragy || fragz || glt->inputwidth != fragwidth || glt->inputheight != fragheight || glt->inputdepth != fragdepth)
 826                         Host_Error("R_Upload: partial update not allowed on initial upload or in combination with PICMIP or MIPMAP\n");
 827
 828                 // upload the image for the first time
 829                 glt->flags &= ~GLTEXF_UPLOAD;
 830
 831                 // cubemaps contain multiple images and thus get processed a bit differently
 832                 if (glt->texturetype != GLTEXTURETYPE_CUBEMAP)
 833                 {
 834                         if (glt->inputwidth != width || glt->inputheight != height || glt->inputdepth != depth)
 835                         {
 836                                 Image_Resample32(prevbuffer, glt->inputwidth, glt->inputheight, glt->inputdepth, resizebuffer, width, height, depth, r_lerpimages.integer);
 837                                 prevbuffer = resizebuffer;
 838                         }
 839                         // picmip/max_size
 840                         while (width > glt->tilewidth || height > glt->tileheight || depth > glt->tiledepth)
 841                         {
 842                                 Image_MipReduce32(prevbuffer, resizebuffer, &width, &height, &depth, glt->tilewidth, glt->tileheight, glt->tiledepth);
 843                                 prevbuffer = resizebuffer;
 844                         }
 845                 }
 846                 mip = 0;
 847                 if (vid.support.arb_texture_compression)
 848                 {
 849                         if (gl_texturecompression.integer >= 2)
 850                                 qglHint(GL_TEXTURE_COMPRESSION_HINT_ARB, GL_NICEST);
 851                         else
 852                                 qglHint(GL_TEXTURE_COMPRESSION_HINT_ARB, GL_FASTEST);
 853                         CHECKGLERROR
 854                 }
 855                 switch(glt->texturetype)
 856                 {
 857                 case GLTEXTURETYPE_2D:
 858                         qglTexImage2D(GL_TEXTURE_2D, mip++, glt->glinternalformat, width, height, 0, glt->glformat, glt->gltype, prevbuffer);CHECKGLERROR
 859                         if (glt->flags & TEXF_MIPMAP)
 860                         {
 861                                 while (width > 1 || height > 1 || depth > 1)
 862                                 {
 863                                         Image_MipReduce32(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1);
 864                                         prevbuffer = resizebuffer;
 865                                         qglTexImage2D(GL_TEXTURE_2D, mip++, glt->glinternalformat, width, height, 0, glt->glformat, glt->gltype, prevbuffer);CHECKGLERROR
 866                                 }
 867                         }
 868                         break;
 869                 case GLTEXTURETYPE_3D:
 870                         qglTexImage3D(GL_TEXTURE_3D, mip++, glt->glinternalformat, width, height, depth, 0, glt->glformat, glt->gltype, prevbuffer);CHECKGLERROR
 871                         if (glt->flags & TEXF_MIPMAP)
 872                         {
 873                                 while (width > 1 || height > 1 || depth > 1)
 874                                 {
 875                                         Image_MipReduce32(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1);
 876                                         prevbuffer = resizebuffer;
 877                                         qglTexImage3D(GL_TEXTURE_3D, mip++, glt->glinternalformat, width, height, depth, 0, glt->glformat, glt->gltype, prevbuffer);CHECKGLERROR
 878                                 }
 879                         }
 880                         break;
 881                 case GLTEXTURETYPE_CUBEMAP:
 882                         // convert and upload each side in turn,
 883                         // from a continuous block of input texels
 884                         texturebuffer = (unsigned char *)prevbuffer;
 885                         for (i = 0;i < 6;i++)
 886                         {
 887                                 prevbuffer = texturebuffer;
 888                                 texturebuffer += glt->inputwidth * glt->inputheight * glt->inputdepth * glt->textype->inputbytesperpixel;
 889                                 if (glt->inputwidth != width || glt->inputheight != height || glt->inputdepth != depth)
 890                                 {
 891                                         Image_Resample32(prevbuffer, glt->inputwidth, glt->inputheight, glt->inputdepth, resizebuffer, width, height, depth, r_lerpimages.integer);
 892                                         prevbuffer = resizebuffer;
 893                                 }
 894                                 // picmip/max_size
 895                                 while (width > glt->tilewidth || height > glt->tileheight || depth > glt->tiledepth)
 896                                 {
 897                                         Image_MipReduce32(prevbuffer, resizebuffer, &width, &height, &depth, glt->tilewidth, glt->tileheight, glt->tiledepth);
 898                                         prevbuffer = resizebuffer;
 899                                 }
 900                                 mip = 0;
 901                                 qglTexImage2D(cubemapside[i], mip++, glt->glinternalformat, width, height, 0, glt->glformat, glt->gltype, prevbuffer);CHECKGLERROR
 902                                 if (glt->flags & TEXF_MIPMAP)
 903                                 {
 904                                         while (width > 1 || height > 1 || depth > 1)
 905                                         {
 906                                                 Image_MipReduce32(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1);
 907                                                 prevbuffer = resizebuffer;
 908                                                 qglTexImage2D(cubemapside[i], mip++, glt->glinternalformat, width, height, 0, glt->glformat, glt->gltype, prevbuffer);CHECKGLERROR
 909                                         }
 910                                 }
 911                         }
 912                         break;
 913                 case GLTEXTURETYPE_RECTANGLE:
 914                         qglTexImage2D(GL_TEXTURE_RECTANGLE_ARB, mip++, glt->glinternalformat, width, height, 0, glt->glformat, glt->gltype, NULL);CHECKGLERROR
 915                         break;
 916                 }
 917                 GL_SetupTextureParameters(glt->flags, glt->textype->textype, glt->texturetype);
 918         }
 919         qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR
 920 }
 921
 922 int R_RealGetTexture(rtexture_t *rt)
 923 {
 924         if (rt)
 925         {
 926                 gltexture_t *glt;
 927                 glt = (gltexture_t *)rt;
 928                 if (glt->flags & GLTEXF_DYNAMIC)
 929                         R_UpdateDynamicTexture(glt);
 930                 if (glt->flags & GLTEXF_UPLOAD)
 931                 {
 932                         CHECKGLERROR
 933                         qglGenTextures(1, (GLuint *)&glt->texnum);CHECKGLERROR
 934                         R_Upload(glt, glt->inputtexels, 0, 0, 0, glt->inputwidth, glt->inputheight, glt->inputdepth);
 935                         if (glt->inputtexels)
 936                         {
 937                                 Mem_Free(glt->inputtexels);
 938                                 glt->inputtexels = NULL;
 939                                 glt->flags |= GLTEXF_DESTROYED;
 940                         }
 941                         else if (glt->flags & GLTEXF_DESTROYED)
 942                                 Con_Printf("R_GetTexture: Texture %s already uploaded and destroyed.  Can not upload original image again.  Uploaded blank texture.\n", glt->identifier);
 943                 }
 944
 945                 return glt->texnum;
 946         }
 947         else
 948                 return 0;
 949 }
 950
 951 static rtexture_t *R_SetupTexture(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, int depth, int sides, int flags, textype_t textype, int texturetype, const unsigned char *data, const unsigned int *palette)
 952 {
 953         int i, size;
 954         gltexture_t *glt;
 955         gltexturepool_t *pool = (gltexturepool_t *)rtexturepool;
 956         textypeinfo_t *texinfo;
 957         int precache;
 958
 959         if (cls.state == ca_dedicated)
 960                 return NULL;
 961
 962         if (texturetype == GLTEXTURETYPE_RECTANGLE && !vid.support.arb_texture_rectangle)
 963         {
 964                 Con_Printf ("R_LoadTexture: rectangle texture not supported by driver\n");
 965                 return NULL;
 966         }
 967         if (texturetype == GLTEXTURETYPE_CUBEMAP && !vid.support.arb_texture_cube_map)
 968         {
 969                 Con_Printf ("R_LoadTexture: cubemap texture not supported by driver\n");
 970                 return NULL;
 971         }
 972         if (texturetype == GLTEXTURETYPE_3D && !vid.support.ext_texture_3d)
 973         {
 974                 Con_Printf ("R_LoadTexture: 3d texture not supported by driver\n");
 975                 return NULL;
 976         }
 977
 978         texinfo = R_GetTexTypeInfo(textype, flags);
 979         size = width * height * depth * sides * texinfo->inputbytesperpixel;
 980         if (size < 1)
 981         {
 982                 Con_Printf ("R_LoadTexture: bogus texture size (%dx%dx%dx%dbppx%dsides = %d bytes)\n", width, height, depth, texinfo->inputbytesperpixel * 8, sides, size);
 983                 return NULL;
 984         }
 985
 986         // clear the alpha flag if the texture has no transparent pixels
 987         switch(textype)
 988         {
 989         case TEXTYPE_PALETTE:
 990                 if (flags & TEXF_ALPHA)
 991                 {
 992                         flags &= ~TEXF_ALPHA;
 993                         if (data)
 994                         {
 995                                 for (i = 0;i < size;i++)
 996                                 {
 997                                         if (((unsigned char *)&palette[data[i]])[3] < 255)
 998                                         {
 999                                                 flags |= TEXF_ALPHA;
1000                                                 break;
1001                                         }
1002                                 }
1003                         }
1004                 }
1005                 break;
1006         case TEXTYPE_RGBA:
1007         case TEXTYPE_BGRA:
1008                 if (flags & TEXF_ALPHA)
1009                 {
1010                         flags &= ~TEXF_ALPHA;
1011                         if (data)
1012                         {
1013                                 for (i = 3;i < size;i += 4)
1014                                 {
1015                                         if (data[i] < 255)
1016                                         {
1017                                                 flags |= TEXF_ALPHA;
1018                                                 break;
1019                                         }
1020                                 }
1021                         }
1022                 }
1023                 break;
1024         case TEXTYPE_SHADOWMAP:
1025                 break;
1026         default:
1027                 Host_Error("R_LoadTexture: unknown texture type");
1028         }
1029
1030         glt = (gltexture_t *)Mem_Alloc(texturemempool, sizeof(gltexture_t));
1031         if (identifier)
1032                 strlcpy (glt->identifier, identifier, sizeof(glt->identifier));
1033         glt->pool = pool;
1034         glt->chain = pool->gltchain;
1035         pool->gltchain = glt;
1036         glt->inputwidth = width;
1037         glt->inputheight = height;
1038         glt->inputdepth = depth;
1039         glt->flags = flags | GLTEXF_UPLOAD;
1040         glt->textype = texinfo;
1041         glt->texturetype = texturetype;
1042         glt->inputdatasize = size;
1043         glt->palette = palette;
1044         glt->glinternalformat = texinfo->glinternalformat;
1045         glt->glformat = texinfo->glformat;
1046         glt->gltype = texinfo->gltype;
1047         glt->bytesperpixel = texinfo->internalbytesperpixel;
1048         glt->sides = glt->texturetype == GLTEXTURETYPE_CUBEMAP ? 6 : 1;
1049         glt->texnum = 0;
1050         // init the dynamic texture attributes, too [11/22/2007 Black]
1051         glt->dirtytexnum = 0;
1052         glt->updatecallback = NULL;
1053         glt->updatacallback_data = NULL;
1054
1055         GL_Texture_CalcImageSize(glt->texturetype, glt->flags, glt->inputwidth, glt->inputheight, glt->inputdepth, &glt->tilewidth, &glt->tileheight, &glt->tiledepth);
1056
1057         precache = false;
1058         if (glt->flags & TEXF_ALWAYSPRECACHE)
1059                 precache = true;
1060         else if (r_precachetextures.integer >= 2)
1061                 precache = true;
1062         else if (r_precachetextures.integer >= 1)
1063                 if (glt->flags & TEXF_PRECACHE)
1064                         precache = true;
1065
1066         if (precache)
1067         {
1068                 // immediate upload (most common case)
1069                 // data may be NULL (blank texture for dynamic rendering)
1070                 CHECKGLERROR
1071                 qglGenTextures(1, (GLuint *)&glt->texnum);CHECKGLERROR
1072                 R_Upload(glt, data, 0, 0, 0, glt->inputwidth, glt->inputheight, glt->inputdepth);
1073         }
1074         else if (data)
1075         {
1076                 // deferred texture upload (menu graphics)
1077                 // optimize first if possible
1078                 if ((textype == TEXTYPE_BGRA || textype == TEXTYPE_RGBA) && glt->inputwidth * glt->inputheight * glt->inputdepth > glt->tilewidth * glt->tileheight * glt->tiledepth)
1079                 {
1080                         glt->inputtexels = (unsigned char *)Mem_Alloc(texturemempool, glt->tilewidth*glt->tileheight*glt->tiledepth*glt->sides*glt->bytesperpixel);
1081                         Image_Resample32(data, glt->inputwidth, glt->inputheight, glt->inputdepth, glt->inputtexels, glt->tilewidth, glt->tileheight, glt->tiledepth, r_lerpimages.integer);
1082                         // change texture size accordingly
1083                         glt->inputwidth = glt->tilewidth;
1084                         glt->inputheight = glt->tileheight;
1085                         glt->inputdepth = glt->tiledepth;
1086                         GL_Texture_CalcImageSize(glt->texturetype, glt->flags, glt->inputwidth, glt->inputheight, glt->inputdepth, &glt->tilewidth, &glt->tileheight, &glt->tiledepth);
1087                 }
1088                 else
1089                 {
1090                         glt->inputtexels = (unsigned char *)Mem_Alloc(texturemempool, size);
1091                         memcpy(glt->inputtexels, data, size);
1092                 }
1093         }
1094
1095         // texture converting and uploading can take a while, so make sure we're sending keepalives
1096         CL_KeepaliveMessage(false);
1097
1098         return (rtexture_t *)glt;
1099 }
1100
1101 rtexture_t *R_LoadTexture2D(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, const unsigned char *data, textype_t textype, int flags, const unsigned int *palette)
1102 {
1103         return R_SetupTexture(rtexturepool, identifier, width, height, 1, 1, flags, textype, GLTEXTURETYPE_2D, data, palette);
1104 }
1105
1106 rtexture_t *R_LoadTexture3D(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, int depth, const unsigned char *data, textype_t textype, int flags, const unsigned int *palette)
1107 {
1108         return R_SetupTexture(rtexturepool, identifier, width, height, depth, 1, flags, textype, GLTEXTURETYPE_3D, data, palette);
1109 }
1110
1111 rtexture_t *R_LoadTextureCubeMap(rtexturepool_t *rtexturepool, const char *identifier, int width, const unsigned char *data, textype_t textype, int flags, const unsigned int *palette)
1112 {
1113         return R_SetupTexture(rtexturepool, identifier, width, width, 1, 6, flags, textype, GLTEXTURETYPE_CUBEMAP, data, palette);
1114 }
1115
1116 rtexture_t *R_LoadTextureRectangle(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, const unsigned char *data, textype_t textype, int flags, const unsigned int *palette)
1117 {
1118         return R_SetupTexture(rtexturepool, identifier, width, height, 1, 1, flags, textype, GLTEXTURETYPE_RECTANGLE, data, palette);
1119 }
1120
1121 static int R_ShadowMapTextureFlags(int precision, qboolean filter)
1122 {
1123         int flags = TEXF_ALWAYSPRECACHE | TEXF_CLAMP;
1124         if (filter)
1125                 flags |= TEXF_FORCELINEAR | TEXF_COMPARE;
1126         else
1127                 flags |= TEXF_FORCENEAREST;
1128         if (precision <= 16)
1129                 flags |= TEXF_LOWPRECISION;
1130         return flags;
1131 }
1132
1133 rtexture_t *R_LoadTextureShadowMapRectangle(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, int precision, qboolean filter)
1134 {
1135         return R_SetupTexture(rtexturepool, identifier, width, height, 1, 1, R_ShadowMapTextureFlags(precision, filter), TEXTYPE_SHADOWMAP, GLTEXTURETYPE_RECTANGLE, NULL, NULL);
1136 }
1137
1138 rtexture_t *R_LoadTextureShadowMap2D(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, int precision, qboolean filter)
1139 {
1140         return R_SetupTexture(rtexturepool, identifier, width, height, 1, 1, R_ShadowMapTextureFlags(precision, filter), TEXTYPE_SHADOWMAP, GLTEXTURETYPE_2D, NULL, NULL);
1141 }
1142
1143 rtexture_t *R_LoadTextureShadowMapCube(rtexturepool_t *rtexturepool, const char *identifier, int width, int precision, qboolean filter)
1144 {
1145     return R_SetupTexture(rtexturepool, identifier, width, width, 1, 6, R_ShadowMapTextureFlags(precision, filter), TEXTYPE_SHADOWMAP, GLTEXTURETYPE_CUBEMAP, NULL, NULL);
1146 }
1147
1148 int R_TextureWidth(rtexture_t *rt)
1149 {
1150         return rt ? ((gltexture_t *)rt)->inputwidth : 0;
1151 }
1152
1153 int R_TextureHeight(rtexture_t *rt)
1154 {
1155         return rt ? ((gltexture_t *)rt)->inputheight : 0;
1156 }
1157
1158 void R_UpdateTexture(rtexture_t *rt, const unsigned char *data, int x, int y, int width, int height)
1159 {
1160         gltexture_t *glt = (gltexture_t *)rt;
1161         if (data == NULL)
1162                 Host_Error("R_UpdateTexture: no data supplied");
1163         if (glt == NULL)
1164                 Host_Error("R_UpdateTexture: no texture supplied");
1165         if (!glt->texnum)
1166                 Host_Error("R_UpdateTexture: texture has not been uploaded yet");
1167         // update part of the texture
1168         R_Upload(glt, data, x, y, 0, width, height, 1);
1169 }
1170
1171 void R_ClearTexture (rtexture_t *rt)
1172 {
1173         gltexture_t *glt = (gltexture_t *)rt;
1174
1175         R_Upload( glt, NULL, 0, 0, 0, glt->tilewidth, glt->tileheight, glt->tiledepth );
1176 }