X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=gl_textures.c;h=8ac8d6cad73cc6a8521ddf252a9621d287591ce4;hp=83444e528b8814091230ae112bc1ba4ad7ae5228;hb=7fe21433f8c26bd2442ab72707f7f6063c1932e7;hpb=6abac2b717bea19c4d9b1c178a129fb3c82142ba diff --git a/gl_textures.c b/gl_textures.c index 83444e52..8ac8d6ca 100644 --- a/gl_textures.c +++ b/gl_textures.c @@ -1,45 +1,259 @@ + #include "quakedef.h" +#include "image.h" +#include "jpeg.h" +#include "image_png.h" + +cvar_t gl_max_size = {CVAR_SAVE, "gl_max_size", "2048", "maximum allowed texture size, can be used to reduce video memory usage, note: this is automatically reduced to match video card capabilities (such as 256 on 3Dfx cards before Voodoo4/5)"}; +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%"}; +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)"}; +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)"}; +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"}; + +int gl_filter_min = GL_LINEAR_MIPMAP_LINEAR; +int gl_filter_mag = GL_LINEAR; -cvar_t gl_max_size = {"gl_max_size", "1024"}; -cvar_t gl_picmip = {"gl_picmip", "0"}; -cvar_t gl_lerpimages = {"gl_lerpimages", "1"}; -cvar_t r_upload = {"r_upload", "1"}; -int gl_filter_min = GL_LINEAR_MIPMAP_LINEAR; //NEAREST; -int gl_filter_max = GL_LINEAR; +static mempool_t *texturemempool; +// note: this must not conflict with TEXF_ flags in r_textures.h +// cleared when a texture is uploaded +#define GLTEXF_UPLOAD 0x00010000 +// bitmask for mismatch checking +#define GLTEXF_IMPORTANTBITS (0) +// set when image is uploaded and freed +#define GLTEXF_DESTROYED 0x00040000 + +typedef struct textypeinfo_s +{ + int textype; + int inputbytesperpixel; + int internalbytesperpixel; + int glformat; + int glinternalformat; +} +textypeinfo_t; + +static textypeinfo_t textype_palette = {TEXTYPE_PALETTE, 1, 4, GL_RGBA , 3}; +static textypeinfo_t textype_rgb = {TEXTYPE_RGB , 3, 3, GL_RGB , 3}; +static textypeinfo_t textype_rgba = {TEXTYPE_RGBA , 4, 4, GL_RGBA , 3}; +static textypeinfo_t textype_palette_alpha = {TEXTYPE_PALETTE, 1, 4, GL_RGBA , 4}; +static textypeinfo_t textype_rgba_alpha = {TEXTYPE_RGBA , 4, 4, GL_RGBA , 4}; + +#define GLTEXTURETYPE_1D 0 +#define GLTEXTURETYPE_2D 1 +#define GLTEXTURETYPE_3D 2 +#define GLTEXTURETYPE_CUBEMAP 3 + +static int gltexturetypeenums[4] = {GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_ARB}; +static int gltexturetypebindingenums[4] = {GL_TEXTURE_BINDING_1D, GL_TEXTURE_BINDING_2D, GL_TEXTURE_BINDING_3D, GL_TEXTURE_BINDING_CUBE_MAP_ARB}; +static int gltexturetypedimensions[4] = {1, 2, 3, 2}; +static int cubemapside[6] = +{ + GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, + GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, + GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, + GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, + GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, + GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB +}; -int texels; +typedef struct gltexture_s +{ + // this field is exposed to the R_GetTexture macro, for speed reasons + // (must be identical in rtexture_t) + int texnum; // GL texture slot number + + // pointer to texturepool (check this to see if the texture is allocated) + struct gltexturepool_s *pool; + // pointer to next texture in texturepool chain + struct gltexture_s *chain; + // name of the texture (this might be removed someday), no duplicates + char identifier[32]; + // original data size in *inputtexels + int inputwidth, inputheight, inputdepth; + // copy of the original texture(s) supplied to the upload function, for + // delayed uploads (non-precached) + unsigned char *inputtexels; + // original data size in *inputtexels + int inputdatasize; + // flags supplied to the LoadTexture function + // (might be altered to remove TEXF_ALPHA), and GLTEXF_ private flags + int flags; + // pointer to one of the textype_ structs + textypeinfo_t *textype; + // one of the GLTEXTURETYPE_ values + int texturetype; + // palette if the texture is TEXTYPE_PALETTE + const unsigned int *palette; + // actual stored texture size after gl_picmip and gl_max_size are applied + // (power of 2 if gl_support_arb_texture_non_power_of_two is not supported) + int tilewidth, tileheight, tiledepth; + // 1 or 6 depending on texturetype + int sides; + // bytes per pixel + int bytesperpixel; + // GL_RGB or GL_RGBA + int glformat; + // 3 or 4 + int glinternalformat; +} +gltexture_t; -// 4096x4096 -#define MAXMIPS 12 +#define TEXTUREPOOL_SENTINEL 0xC0DEDBAD -typedef struct +typedef struct gltexturepool_s { - int texnum; - byte *texels[MAXMIPS]; - unsigned short texelsize[MAXMIPS][2]; - char identifier[64]; - short width, height; -// LordHavoc: CRC to identify cache mismatchs - unsigned short crc; - char mipmap; - char alpha; - char bytesperpixel; - char lerped; // whether this texture was uploaded with or without interpolation -} gltexture_t; + unsigned int sentinel; + struct gltexture_s *gltchain; + struct gltexturepool_s *next; +} +gltexturepool_t; + +static gltexturepool_t *gltexturepoolchain = NULL; -#define MAX_GLTEXTURES 4096 -gltexture_t gltextures[MAX_GLTEXTURES]; -int numgltextures; +static unsigned char *resizebuffer = NULL, *colorconvertbuffer; +static int resizebuffersize = 0; +static unsigned char *texturebuffer; +static int texturebuffersize = 0; -typedef struct +static textypeinfo_t *R_GetTexTypeInfo(int textype, int flags) +{ + if (flags & TEXF_ALPHA) + { + switch(textype) + { + case TEXTYPE_PALETTE: + return &textype_palette_alpha; + case TEXTYPE_RGB: + Host_Error("R_GetTexTypeInfo: RGB format has no alpha, TEXF_ALPHA not allowed"); + return NULL; + case TEXTYPE_RGBA: + return &textype_rgba_alpha; + default: + Host_Error("R_GetTexTypeInfo: unknown texture format"); + return NULL; + } + } + else + { + switch(textype) + { + case TEXTYPE_PALETTE: + return &textype_palette; + case TEXTYPE_RGB: + return &textype_rgb; + case TEXTYPE_RGBA: + return &textype_rgba; + default: + Host_Error("R_GetTexTypeInfo: unknown texture format"); + return NULL; + } + } +} + +static void R_UploadTexture(gltexture_t *t); + +static void R_PrecacheTexture(gltexture_t *glt) +{ + int precache; + precache = false; + if (glt->flags & TEXF_ALWAYSPRECACHE) + precache = true; + else if (r_precachetextures.integer >= 2) + precache = true; + else if (r_precachetextures.integer >= 1) + if (glt->flags & TEXF_PRECACHE) + precache = true; + + if (precache) + R_UploadTexture(glt); +} + +int R_RealGetTexture(rtexture_t *rt) +{ + if (rt) + { + gltexture_t *glt; + glt = (gltexture_t *)rt; + if (glt->flags & GLTEXF_UPLOAD) + R_UploadTexture(glt); + return glt->texnum; + } + else + return 0; +} + +void R_FreeTexture(rtexture_t *rt) +{ + gltexture_t *glt, **gltpointer; + + glt = (gltexture_t *)rt; + if (glt == NULL) + Host_Error("R_FreeTexture: texture == NULL"); + + for (gltpointer = &glt->pool->gltchain;*gltpointer && *gltpointer != glt;gltpointer = &(*gltpointer)->chain); + if (*gltpointer == glt) + *gltpointer = glt->chain; + else + Host_Error("R_FreeTexture: texture \"%s\" not linked in pool", glt->identifier); + + if (glt->texnum) + { + CHECKGLERROR + qglDeleteTextures(1, (GLuint *)&glt->texnum);CHECKGLERROR + } + + if (glt->inputtexels) + Mem_Free(glt->inputtexels); + Mem_Free(glt); +} + +rtexturepool_t *R_AllocTexturePool(void) +{ + gltexturepool_t *pool; + if (texturemempool == NULL) + return NULL; + pool = (gltexturepool_t *)Mem_Alloc(texturemempool, sizeof(gltexturepool_t)); + if (pool == NULL) + return NULL; + pool->next = gltexturepoolchain; + gltexturepoolchain = pool; + pool->sentinel = TEXTUREPOOL_SENTINEL; + return (rtexturepool_t *)pool; +} + +void R_FreeTexturePool(rtexturepool_t **rtexturepool) +{ + gltexturepool_t *pool, **poolpointer; + if (rtexturepool == NULL) + return; + if (*rtexturepool == NULL) + return; + pool = (gltexturepool_t *)(*rtexturepool); + *rtexturepool = NULL; + if (pool->sentinel != TEXTUREPOOL_SENTINEL) + Host_Error("R_FreeTexturePool: pool already freed"); + for (poolpointer = &gltexturepoolchain;*poolpointer && *poolpointer != pool;poolpointer = &(*poolpointer)->next); + if (*poolpointer == pool) + *poolpointer = pool->next; + else + Host_Error("R_FreeTexturePool: pool not linked"); + while (pool->gltchain) + R_FreeTexture((rtexture_t *)pool->gltchain); + Mem_Free(pool); +} + + +typedef struct glmode_s { char *name; - int minimize, maximize; -} glmode_t; + int minification, magnification; +} +glmode_t; -glmode_t modes[] = { +static glmode_t modes[6] = +{ {"GL_NEAREST", GL_NEAREST, GL_NEAREST}, {"GL_LINEAR", GL_LINEAR, GL_LINEAR}, {"GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST}, @@ -48,894 +262,732 @@ glmode_t modes[] = { {"GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR} }; -/* -=============== -Draw_TextureMode_f -=============== -*/ -void Draw_TextureMode_f (void) +static void GL_TextureMode_f (void) { - int i; - gltexture_t *glt; + int i; + GLint oldbindtexnum; + gltexture_t *glt; + gltexturepool_t *pool; if (Cmd_Argc() == 1) { - for (i=0 ; i< 6 ; i++) - if (gl_filter_min == modes[i].minimize) + for (i = 0;i < 6;i++) + { + if (gl_filter_min == modes[i].minification) { - Con_Printf ("%s\n", modes[i].name); + Con_Printf("%s\n", modes[i].name); return; } - Con_Printf ("current filter is unknown???\n"); + } + Con_Print("current filter is unknown???\n"); return; } - for (i=0 ; i< 6 ; i++) - { - if (!Q_strcasecmp (modes[i].name, Cmd_Argv(1) ) ) + for (i = 0;i < 6;i++) + if (!strcasecmp (modes[i].name, Cmd_Argv(1) ) ) break; - } if (i == 6) { - Con_Printf ("bad filter name\n"); + Con_Print("bad filter name\n"); return; } - gl_filter_min = modes[i].minimize; - gl_filter_max = modes[i].maximize; + gl_filter_min = modes[i].minification; + gl_filter_mag = modes[i].magnification; - if (!r_upload.value) - return; // change all the existing mipmap texture objects - for (i=0, glt=gltextures ; inext) { - if (glt->mipmap) + for (glt = pool->gltchain;glt;glt = glt->chain) { - glBindTexture(GL_TEXTURE_2D, glt->texnum); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + // only update already uploaded images + if (!(glt->flags & (GLTEXF_UPLOAD | TEXF_FORCENEAREST | TEXF_FORCELINEAR))) + { + qglGetIntegerv(gltexturetypebindingenums[glt->texturetype], &oldbindtexnum);CHECKGLERROR + qglBindTexture(gltexturetypeenums[glt->texturetype], glt->texnum);CHECKGLERROR + if (glt->flags & TEXF_MIPMAP) + { + qglTexParameteri(gltexturetypeenums[glt->texturetype], GL_TEXTURE_MIN_FILTER, gl_filter_min);CHECKGLERROR + } + else + { + qglTexParameteri(gltexturetypeenums[glt->texturetype], GL_TEXTURE_MIN_FILTER, gl_filter_mag);CHECKGLERROR + } + qglTexParameteri(gltexturetypeenums[glt->texturetype], GL_TEXTURE_MAG_FILTER, gl_filter_mag);CHECKGLERROR + qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR + } } } } -extern int buildnumber; - -char engineversion[40]; - -void GL_UploadTexture (gltexture_t *glt); -void gl_textures_start() +static void GL_Texture_CalcImageSize(int texturetype, int flags, int inwidth, int inheight, int indepth, int *outwidth, int *outheight, int *outdepth) { - int i; - gltexture_t *glt; - for (i=0, glt=gltextures ; i gl_max_texture_size) + Cvar_SetValue("gl_max_size", gl_max_texture_size); -void GL_Textures_Init (void) -{ - Cvar_RegisterVariable (&gl_max_size); - Cvar_RegisterVariable (&gl_picmip); - Cvar_RegisterVariable (&gl_lerpimages); - Cvar_RegisterVariable (&r_upload); -#ifdef NORENDER - r_upload.value = 0; -#endif - - // 3dfx can only handle 256 wide textures - if (!Q_strncasecmp ((char *)gl_renderer, "3dfx",4) || strstr((char *)gl_renderer, "Glide")) - Cvar_Set ("gl_max_size", "256"); - - Cmd_AddCommand ("gl_texturemode", &Draw_TextureMode_f); - - R_RegisterModule("GL_Textures", gl_textures_start, gl_textures_shutdown); -} - -/* -================ -GL_FindTexture -================ -*/ -int GL_FindTexture (char *identifier) -{ - int i; - gltexture_t *glt; - - for (i=0, glt=gltextures ; iidentifier)) - return gltextures[i].texnum; + default: + case GLTEXTURETYPE_1D: + case GLTEXTURETYPE_2D: + maxsize = gl_max_texture_size; + break; + case GLTEXTURETYPE_3D: + maxsize = gl_max_3d_texture_size; + break; + case GLTEXTURETYPE_CUBEMAP: + maxsize = gl_max_cube_map_texture_size; + break; } - return -1; -} - -extern byte qgamma[]; + if (flags & TEXF_PICMIP) + { + maxsize = min(maxsize, gl_max_size.integer); + picmip = gl_picmip.integer; + } -// LordHavoc: gamma correction and improved resampling -void GL_ResampleTextureLerpLine (byte *in, byte *out, int inwidth, int outwidth) -{ - int j, xi, oldx = 0, f, fstep, l1, l2, endx; - fstep = (int) (inwidth*65536.0f/outwidth); - endx = (inwidth-1); - for (j = 0,f = 0;j < outwidth;j++, f += fstep) + if (outwidth) { - xi = (int) f >> 16; - if (xi != oldx) + if (gl_support_arb_texture_non_power_of_two) + width2 = min(inwidth >> picmip, maxsize); + else { - in += (xi - oldx) * 4; - oldx = xi; + for (width2 = 1;width2 < inwidth;width2 <<= 1); + for (width2 >>= picmip;width2 > maxsize;width2 >>= 1); } - if (xi < endx) + *outwidth = max(1, width2); + } + if (outheight) + { + if (gl_support_arb_texture_non_power_of_two) + height2 = min(inheight >> picmip, maxsize); + else { - l2 = f & 0xFFFF; - l1 = 0x10000 - l2; - *out++ = (byte) ((in[0] * l1 + in[4] * l2) >> 16); - *out++ = (byte) ((in[1] * l1 + in[5] * l2) >> 16); - *out++ = (byte) ((in[2] * l1 + in[6] * l2) >> 16); - *out++ = (byte) ((in[3] * l1 + in[7] * l2) >> 16); -// *out++ = qgamma[(byte) ((in[0] * l1 + in[4] * l2) >> 16)]; -// *out++ = qgamma[(byte) ((in[1] * l1 + in[5] * l2) >> 16)]; -// *out++ = qgamma[(byte) ((in[2] * l1 + in[6] * l2) >> 16)]; -// *out++ = (byte) ((in[3] * l1 + in[7] * l2) >> 16) ; + for (height2 = 1;height2 < inheight;height2 <<= 1); + for (height2 >>= picmip;height2 > maxsize;height2 >>= 1); } - else // last pixel of the line has no pixel to lerp to + *outheight = max(1, height2); + } + if (outdepth) + { + if (gl_support_arb_texture_non_power_of_two) + depth2 = min(indepth >> picmip, maxsize); + else { - *out++ = in[0]; - *out++ = in[1]; - *out++ = in[2]; - *out++ = in[3]; -// *out++ = qgamma[in[0]]; -// *out++ = qgamma[in[1]]; -// *out++ = qgamma[in[2]]; -// *out++ = in[3] ; + for (depth2 = 1;depth2 < indepth;depth2 <<= 1); + for (depth2 >>= picmip;depth2 > maxsize;depth2 >>= 1); } + *outdepth = max(1, depth2); } } -/* -================ -GL_ResampleTexture -================ -*/ -void GL_ResampleTexture (void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight) + +static int R_CalcTexelDataSize (gltexture_t *glt) { - // LordHavoc: gamma correction and greatly improved resampling - if (gl_lerpimages.value) - { - int i, j, yi, oldy, f, fstep, l1, l2, endy = (inheight-1); - byte *inrow, *out, *row1, *row2; - out = outdata; - fstep = (int) (inheight*65536.0f/outheight); + int width2, height2, depth2, size; - row1 = malloc(outwidth*4); - row2 = malloc(outwidth*4); - inrow = indata; - oldy = 0; - GL_ResampleTextureLerpLine (inrow, row1, inwidth, outwidth); - GL_ResampleTextureLerpLine (inrow + inwidth*4, row2, inwidth, outwidth); - for (i = 0, f = 0;i < outheight;i++,f += fstep) + GL_Texture_CalcImageSize(glt->texturetype, glt->flags, glt->inputwidth, glt->inputheight, glt->inputdepth, &width2, &height2, &depth2); + + size = width2 * height2 * depth2; + + if (glt->flags & TEXF_MIPMAP) + { + while (width2 > 1 || height2 > 1 || depth2 > 1) { - yi = f >> 16; - if (yi != oldy) - { - inrow = (byte *)indata + inwidth*4*yi; - if (yi == oldy+1) - memcpy(row1, row2, outwidth*4); - else - GL_ResampleTextureLerpLine (inrow, row1, inwidth, outwidth); - if (yi < endy) - GL_ResampleTextureLerpLine (inrow + inwidth*4, row2, inwidth, outwidth); - else - memcpy(row2, row1, outwidth*4); - oldy = yi; - } - if (yi < endy) - { - l2 = f & 0xFFFF; - l1 = 0x10000 - l2; - for (j = 0;j < outwidth;j++) - { - *out++ = (byte) ((*row1++ * l1 + *row2++ * l2) >> 16); - *out++ = (byte) ((*row1++ * l1 + *row2++ * l2) >> 16); - *out++ = (byte) ((*row1++ * l1 + *row2++ * l2) >> 16); - *out++ = (byte) ((*row1++ * l1 + *row2++ * l2) >> 16); - } - row1 -= outwidth*4; - row2 -= outwidth*4; - } - else // last line has no pixels to lerp to - { - for (j = 0;j < outwidth;j++) - { - *out++ = *row1++; - *out++ = *row1++; - *out++ = *row1++; - *out++ = *row1++; - } - row1 -= outwidth*4; - } + if (width2 > 1) + width2 >>= 1; + if (height2 > 1) + height2 >>= 1; + if (depth2 > 1) + depth2 >>= 1; + size += width2 * height2 * depth2; } - free(row1); - free(row2); } - else - { - int i, j; - unsigned frac, fracstep; - byte *inrow, *out, *inpix; - out = outdata; - fracstep = inwidth*0x10000/outwidth; - for (i=0 ; itextype->internalbytesperpixel * glt->sides; +} + +void R_TextureStats_Print(qboolean printeach, qboolean printpool, qboolean printtotal) +{ + int glsize; + int isloaded; + int pooltotal = 0, pooltotalt = 0, pooltotalp = 0, poolloaded = 0, poolloadedt = 0, poolloadedp = 0; + int sumtotal = 0, sumtotalt = 0, sumtotalp = 0, sumloaded = 0, sumloadedt = 0, sumloadedp = 0; + gltexture_t *glt; + gltexturepool_t *pool; + if (printeach) + Con_Print("glsize input loaded mip alpha name\n"); + for (pool = gltexturepoolchain;pool;pool = pool->next) + { + pooltotal = 0; + pooltotalt = 0; + pooltotalp = 0; + poolloaded = 0; + poolloadedt = 0; + poolloadedp = 0; + for (glt = pool->gltchain;glt;glt = glt->chain) { - inrow = (byte *)indata + inwidth*(i*inheight/outheight)*4; - frac = fracstep >> 1; - for (j=0 ; jflags & GLTEXF_UPLOAD); + pooltotal++; + pooltotalt += glsize; + pooltotalp += glt->inputdatasize; + if (isloaded) { - inpix = inrow + ((frac >> 14) & ~3);*out++ = qgamma[*inpix++];*out++ = qgamma[*inpix++];*out++ = qgamma[*inpix++];*out++ = *inpix++ ;frac += fracstep; - inpix = inrow + ((frac >> 14) & ~3);*out++ = qgamma[*inpix++];*out++ = qgamma[*inpix++];*out++ = qgamma[*inpix++];*out++ = *inpix++ ;frac += fracstep; - inpix = inrow + ((frac >> 14) & ~3);*out++ = qgamma[*inpix++];*out++ = qgamma[*inpix++];*out++ = qgamma[*inpix++];*out++ = *inpix++ ;frac += fracstep; - inpix = inrow + ((frac >> 14) & ~3);*out++ = qgamma[*inpix++];*out++ = qgamma[*inpix++];*out++ = qgamma[*inpix++];*out++ = *inpix++ ;frac += fracstep; + poolloaded++; + poolloadedt += glsize; + poolloadedp += glt->inputdatasize; } + if (printeach) + 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); } - } + if (printpool) + Con_Printf("texturepool %10p total: %i (%.3fMB, %.3fMB original), uploaded %i (%.3fMB, %.3fMB original), upload on demand %i (%.3fMB, %.3fMB original)\n", 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); + sumtotal += pooltotal; + sumtotalt += pooltotalt; + sumtotalp += pooltotalp; + sumloaded += poolloaded; + sumloadedt += poolloadedt; + sumloadedp += poolloadedp; + } + if (printtotal) + 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); } -/* -================ -GL_Resample8BitTexture -- JACK -================ -*/ -/* -void GL_Resample8BitTexture (unsigned char *in, int inwidth, int inheight, unsigned char *out, int outwidth, int outheight) +static void R_TextureStats_f(void) { - int i, j; - unsigned char *inrow; - unsigned frac, fracstep; + R_TextureStats_Print(true, true, true); +} - fracstep = inwidth*0x10000/outwidth; - for (i=0 ; i> 1; - for (j=0 ; j>16];frac += fracstep; - out[j+1] = inrow[frac>>16];frac += fracstep; - out[j+2] = inrow[frac>>16];frac += fracstep; - out[j+3] = inrow[frac>>16];frac += fracstep; - } + temp = (rtexturepool_t *) gltexturepoolchain; + R_FreeTexturePool(&temp); } + + resizebuffersize = 0; + texturebuffersize = 0; + resizebuffer = NULL; + colorconvertbuffer = NULL; + texturebuffer = NULL; + Mem_FreePool(&texturemempool); +} + +static void r_textures_newmap(void) +{ } -*/ +void R_Textures_Init (void) +{ + Cmd_AddCommand("gl_texturemode", &GL_TextureMode_f, "set texture filtering mode (GL_NEAREST, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, etc)"); + Cmd_AddCommand("r_texturestats", R_TextureStats_f, "print information about all loaded textures and some statistics"); + Cvar_RegisterVariable (&gl_max_size); + Cvar_RegisterVariable (&gl_picmip); + Cvar_RegisterVariable (&r_lerpimages); + Cvar_RegisterVariable (&r_precachetextures); + Cvar_RegisterVariable (&gl_texture_anisotropy); -/* -================ -GL_MipMap + R_RegisterModule("R_Textures", r_textures_start, r_textures_shutdown, r_textures_newmap); +} -Operates in place, quartering the size of the texture -================ -*/ -/* -void GL_MipMap (byte *in, int width, int height) +void R_Textures_Frame (void) { - int i, j; - byte *out; + static int old_aniso = 0; + + // could do procedural texture animation here, if we keep track of which + // textures were accessed this frame... - width <<=2; - height >>= 1; - out = in; - for (i=0 ; i>2; - out[1] = (in[1] + in[5] + in[width+1] + in[width+5])>>2; - out[2] = (in[2] + in[6] + in[width+2] + in[width+6])>>2; - out[3] = (in[3] + in[7] + in[width+3] + in[width+7])>>2; - } + Mem_Free(resizebuffer); + resizebuffer = NULL; + } + if (colorconvertbuffer) + { + Mem_Free(colorconvertbuffer); + colorconvertbuffer = NULL; } -} -*/ -/* -================ -GL_MipMap8Bit + if (old_aniso != gl_texture_anisotropy.integer) + { + gltexture_t *glt; + gltexturepool_t *pool; + GLint oldbindtexnum; -Mipping for 8 bit textures -================ -*/ -/* -void GL_MipMap8Bit (byte *in, int width, int height) -{ - int i, j; - unsigned short r,g,b; - byte *out, *at1, *at2, *at3, *at4; + old_aniso = bound(1, gl_texture_anisotropy.integer, gl_max_anisotropy); - height >>= 1; - out = in; - for (i=0 ; inext) { - at1 = (byte *) (d_8to24table + in[0]); - at2 = (byte *) (d_8to24table + in[1]); - at3 = (byte *) (d_8to24table + in[width+0]); - at4 = (byte *) (d_8to24table + in[width+1]); + for (glt = pool->gltchain;glt;glt = glt->chain) + { + // only update already uploaded images + if ((glt->flags & (GLTEXF_UPLOAD | TEXF_MIPMAP)) == TEXF_MIPMAP) + { + qglGetIntegerv(gltexturetypebindingenums[glt->texturetype], &oldbindtexnum);CHECKGLERROR - r = (at1[0]+at2[0]+at3[0]+at4[0]); r>>=5; - g = (at1[1]+at2[1]+at3[1]+at4[1]); g>>=5; - b = (at1[2]+at2[2]+at3[2]+at4[2]); b>>=5; + qglBindTexture(gltexturetypeenums[glt->texturetype], glt->texnum);CHECKGLERROR + qglTexParameteri(gltexturetypeenums[glt->texturetype], GL_TEXTURE_MAX_ANISOTROPY_EXT, old_aniso);CHECKGLERROR - out[0] = d_15to8table[(r<<0) + (g<<5) + (b<<10)]; + qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR + } + } } } } -*/ -/* -=============== -GL_Upload32 -=============== -*/ -/* -void GL_Upload32 (void *data, int width, int height, qboolean mipmap, qboolean alpha) +void R_MakeResizeBufferBigger(int size) { - int samples, scaled_width, scaled_height, i; - byte *in, *out, *scaled; - - for (scaled_width = 1 ; scaled_width < width ; scaled_width<<=1) - ; - for (scaled_height = 1 ; scaled_height < height ; scaled_height<<=1) - ; + if (resizebuffersize < size) + { + resizebuffersize = size; + if (resizebuffer) + Mem_Free(resizebuffer); + if (colorconvertbuffer) + Mem_Free(colorconvertbuffer); + resizebuffer = (unsigned char *)Mem_Alloc(texturemempool, resizebuffersize); + colorconvertbuffer = (unsigned char *)Mem_Alloc(texturemempool, resizebuffersize); + if (!resizebuffer || !colorconvertbuffer) + Host_Error("R_Upload: out of memory"); + } +} - scaled_width >>= (int)gl_picmip.value; - scaled_height >>= (int)gl_picmip.value; +static void GL_SetupTextureParameters(int flags, int texturetype) +{ + int textureenum = gltexturetypeenums[texturetype]; + int wrapmode = ((flags & TEXF_CLAMP) && gl_support_clamptoedge) ? GL_CLAMP_TO_EDGE : GL_REPEAT; - if (scaled_width > gl_max_size.value) - scaled_width = gl_max_size.value; - if (scaled_height > gl_max_size.value) - scaled_height = gl_max_size.value; + CHECKGLERROR - if (alpha) + if (gl_support_anisotropy && (flags & TEXF_MIPMAP)) { - alpha = false; - in = data; - for (i = 3;i < width*height*4;i += 4) - if (in[i] != 255) - { - alpha = true; - break; - } + int aniso = bound(1, gl_texture_anisotropy.integer, gl_max_anisotropy); + if (gl_texture_anisotropy.integer != aniso) + Cvar_SetValueQuick(&gl_texture_anisotropy, aniso); + qglTexParameteri(textureenum, GL_TEXTURE_MAX_ANISOTROPY_EXT, aniso);CHECKGLERROR } - - samples = alpha ? gl_alpha_format : gl_solid_format; - - texels += scaled_width * scaled_height; - - scaled = malloc(scaled_width*scaled_height*4); - if (scaled_width == width && scaled_height == height) + qglTexParameteri(textureenum, GL_TEXTURE_WRAP_S, wrapmode);CHECKGLERROR + qglTexParameteri(textureenum, GL_TEXTURE_WRAP_T, wrapmode);CHECKGLERROR + if (gltexturetypedimensions[texturetype] >= 3) { - // LordHavoc: gamma correct while copying - in = (byte *)data; - out = (byte *)scaled; - for (i = 0;i < width*height;i++) - { - *out++ = qgamma[*in++]; - *out++ = qgamma[*in++]; - *out++ = qgamma[*in++]; - *out++ = *in++; - } + qglTexParameteri(textureenum, GL_TEXTURE_WRAP_R, wrapmode);CHECKGLERROR } - else - GL_ResampleTexture (data, width, height, scaled, scaled_width, scaled_height); - glTexImage2D (GL_TEXTURE_2D, 0, samples, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaled); - if (mipmap) + CHECKGLERROR + if (flags & TEXF_FORCENEAREST) { - int miplevel; - - miplevel = 0; - while (scaled_width > 1 || scaled_height > 1) + if (flags & TEXF_MIPMAP) { - GL_MipMap ((byte *)scaled, scaled_width, scaled_height); - scaled_width >>= 1; - scaled_height >>= 1; - if (scaled_width < 1) - scaled_width = 1; - if (scaled_height < 1) - scaled_height = 1; - miplevel++; - glTexImage2D (GL_TEXTURE_2D, miplevel, samples, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaled); + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);CHECKGLERROR } + else + { + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_NEAREST);CHECKGLERROR + } + qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, GL_NEAREST);CHECKGLERROR } - - if (mipmap) + else if (flags & TEXF_FORCELINEAR) { - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + if (flags & TEXF_MIPMAP) + { + if (gl_filter_min == GL_NEAREST_MIPMAP_LINEAR || gl_filter_min == GL_LINEAR_MIPMAP_LINEAR) + { + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);CHECKGLERROR + } + else + { + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);CHECKGLERROR + } + } + else + { + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_LINEAR);CHECKGLERROR + } + qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, GL_LINEAR);CHECKGLERROR } else { - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + if (flags & TEXF_MIPMAP) + { + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, gl_filter_min);CHECKGLERROR + } + else + { + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, gl_filter_mag);CHECKGLERROR + } + qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, gl_filter_mag);CHECKGLERROR } - free(scaled); + + CHECKGLERROR } -void GL_Upload8_EXT (byte *data, int width, int height, qboolean mipmap) +static void R_Upload(gltexture_t *glt, unsigned char *data, int fragx, int fragy, int fragz, int fragwidth, int fragheight, int fragdepth) { - int scaled_width, scaled_height; - byte *scaled = NULL; + int i, mip, width, height, depth; + GLint oldbindtexnum; + unsigned char *prevbuffer; + prevbuffer = data; - for (scaled_width = 1 ; scaled_width < width ; scaled_width<<=1) - ; - for (scaled_height = 1 ; scaled_height < height ; scaled_height<<=1) - ; + CHECKGLERROR - scaled_width >>= (int)gl_picmip.value; - scaled_height >>= (int)gl_picmip.value; + // we need to restore the texture binding after finishing the upload + qglGetIntegerv(gltexturetypebindingenums[glt->texturetype], &oldbindtexnum);CHECKGLERROR + qglBindTexture(gltexturetypeenums[glt->texturetype], glt->texnum);CHECKGLERROR - if (scaled_width > gl_max_size.value) - scaled_width = gl_max_size.value; - if (scaled_height > gl_max_size.value) - scaled_height = gl_max_size.value; - - texels += scaled_width * scaled_height; - - if (scaled_width == width && scaled_height == height) + // these are rounded up versions of the size to do better resampling + if (gl_support_arb_texture_non_power_of_two) { - if (!mipmap) - { - glTexImage2D (GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, scaled_width, scaled_height, 0, GL_COLOR_INDEX , GL_UNSIGNED_BYTE, data); - goto done; - } - scaled = malloc(scaled_width*scaled_height*4); - memcpy (scaled, data, width*height); + width = glt->inputwidth; + height = glt->inputheight; + depth = glt->inputdepth; } else { - scaled = malloc(scaled_width*scaled_height*4); - GL_Resample8BitTexture (data, width, height, (void*) scaled, scaled_width, scaled_height); + for (width = 1;width < glt->inputwidth ;width <<= 1); + for (height = 1;height < glt->inputheight;height <<= 1); + for (depth = 1;depth < glt->inputdepth ;depth <<= 1); } - glTexImage2D (GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, scaled_width, scaled_height, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, scaled); - if (mipmap) - { - int miplevel; - - miplevel = 0; - while (scaled_width > 1 || scaled_height > 1) - { - GL_MipMap8Bit ((byte *)scaled, scaled_width, scaled_height); - scaled_width >>= 1; - scaled_height >>= 1; - if (scaled_width < 1) - scaled_width = 1; - if (scaled_height < 1) - scaled_height = 1; - miplevel++; - glTexImage2D (GL_TEXTURE_2D, miplevel, GL_COLOR_INDEX8_EXT, scaled_width, scaled_height, 0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, scaled); - } - } -done: ; + R_MakeResizeBufferBigger(width * height * depth * glt->sides * glt->bytesperpixel); + R_MakeResizeBufferBigger(fragwidth * fragheight * fragdepth * glt->sides * glt->bytesperpixel); - - if (mipmap) + if (prevbuffer == NULL) { - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + memset(resizebuffer, 0, fragwidth * fragheight * fragdepth * glt->bytesperpixel); + prevbuffer = resizebuffer; } - else + else if (glt->textype->textype == TEXTYPE_PALETTE) { - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + // promote paletted to RGBA, so we only have to worry about RGB and + // RGBA in the rest of this code + Image_Copy8bitRGBA(prevbuffer, colorconvertbuffer, fragwidth * fragheight * fragdepth * glt->sides, glt->palette); + prevbuffer = colorconvertbuffer; } - free(scaled); -} -*/ -extern qboolean VID_Is8bit(); - -/* -=============== -GL_Upload8 -=============== -*/ -/* -void GL_Upload8 (byte *data, int width, int height, qboolean mipmap, qboolean alpha) -{ - static unsigned *trans; - int i, s; - qboolean noalpha; - int p; - byte *indata; - int *outdata; - - s = width*height; - trans = malloc(s*4); - // if there are no transparent pixels, make it a 3 component - // texture even if it was specified as otherwise - if (alpha) + if ((glt->flags & (TEXF_MIPMAP | TEXF_PICMIP | GLTEXF_UPLOAD)) == 0 && glt->inputwidth == glt->tilewidth && glt->inputheight == glt->tileheight && glt->inputdepth == glt->tiledepth) { - noalpha = true; - for (i=0 ; itexturetype) { - p = data[i]; - if (p != 255) - trans[i] = d_8to24table[p]; - else - { - trans[i] = 0; // force to black - noalpha = false; - } - } - - if (noalpha) - { - if (VID_Is8bit() && (data!=scrap_texels[0])) - { - GL_Upload8_EXT (data, width, height, mipmap); - free(trans); - return; - } - alpha = false; + case GLTEXTURETYPE_1D: + qglTexSubImage1D(GL_TEXTURE_1D, 0, fragx, fragwidth, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR + break; + case GLTEXTURETYPE_2D: + qglTexSubImage2D(GL_TEXTURE_2D, 0, fragx, fragy, fragwidth, fragheight, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR + break; + case GLTEXTURETYPE_3D: + qglTexSubImage3D(GL_TEXTURE_3D, 0, fragx, fragy, fragz, fragwidth, fragheight, fragdepth, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR + break; + default: + Host_Error("R_Upload: partial update of type other than 1D, 2D, or 3D"); + break; } } else { - // LordHavoc: dodge the copy if it will be uploaded as 8bit - if (VID_Is8bit() && (data!=scrap_texels[0])) - { - GL_Upload8_EXT (data, width, height, mipmap); - free(trans); - return; - } - //if (s&3) - // Sys_Error ("GL_Upload8: s&3"); - indata = data; - outdata = trans; - if (s&1) - *outdata++ = d_8to24table[*indata++]; - if (s&2) - { - *outdata++ = d_8to24table[*indata++]; - *outdata++ = d_8to24table[*indata++]; - } - for (i = 0;i < s;i+=4) - { - *outdata++ = d_8to24table[*indata++]; - *outdata++ = d_8to24table[*indata++]; - *outdata++ = d_8to24table[*indata++]; - *outdata++ = d_8to24table[*indata++]; - } - } + if (fragx || fragy || fragz || glt->inputwidth != fragwidth || glt->inputheight != fragheight || glt->inputdepth != fragdepth) + Host_Error("R_Upload: partial update not allowed on initial upload or in combination with PICMIP or MIPMAP\n"); - GL_Upload32 (trans, width, height, mipmap, alpha); - free(trans); -} -*/ + // upload the image for the first time + glt->flags &= ~GLTEXF_UPLOAD; -void GL_AllocTexels(gltexture_t *glt, int width, int height, int mipmapped) -{ - int i, w, h, size, done; - if (glt->texels[0]) - free(glt->texels[0]); - glt->texelsize[0][0] = width; - glt->texelsize[0][1] = height; - if (mipmapped) - { - size = 0; - w = width;h = height; - i = 0; - done = false; - for (i = 0;i < MAXMIPS;i++) + // cubemaps contain multiple images and thus get processed a bit differently + if (glt->texturetype != GLTEXTURETYPE_CUBEMAP) { - glt->texelsize[i][0] = w; - glt->texelsize[i][1] = h; - glt->texels[i] = (void *)size; - size += w*h*4; - if (w > 1) + if (glt->inputwidth != width || glt->inputheight != height || glt->inputdepth != depth) { - w >>= 1; - if (h > 1) - h >>= 1; + Image_Resample(prevbuffer, glt->inputwidth, glt->inputheight, glt->inputdepth, resizebuffer, width, height, depth, glt->bytesperpixel, r_lerpimages.integer); + prevbuffer = resizebuffer; } - else if (h > 1) - h >>= 1; - else + // picmip/max_size + while (width > glt->tilewidth || height > glt->tileheight || depth > glt->tiledepth) { - i++; - break; + Image_MipReduce(prevbuffer, resizebuffer, &width, &height, &depth, glt->tilewidth, glt->tileheight, glt->tiledepth, glt->bytesperpixel); + prevbuffer = resizebuffer; } } - while (i < MAXMIPS) - glt->texels[i++] = NULL; - glt->texels[0] = malloc(size); - for (i = 1;i < MAXMIPS && glt->texels[i];i++) - glt->texels[i] += (int) glt->texels[0]; - } - else - { - glt->texels[0] = malloc(width*height*4); - for (i = 1;i < MAXMIPS;i++) - glt->texels[i] = NULL; - } - if (!glt->texels[0]) - Sys_Error("GL_AllocTexels: out of memory\n"); -} - -// in can be the same as out -void GL_MipReduce(byte *in, byte *out, int width, int height, int destwidth, int destheight) -{ - int x, y, width2, height2, nextrow; - if (width > destwidth) - { - if (height > destheight) + mip = 0; + switch(glt->texturetype) { - // reduce both - width2 = width >> 1; - height2 = height >> 1; - nextrow = width << 2; - for (y = 0;y < height2;y++) + case GLTEXTURETYPE_1D: + qglTexImage1D(GL_TEXTURE_1D, mip++, glt->glinternalformat, width, 0, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR + if (glt->flags & TEXF_MIPMAP) { - for (x = 0;x < width2;x++) + while (width > 1 || height > 1 || depth > 1) { - out[0] = (byte) ((in[0] + in[4] + in[nextrow ] + in[nextrow+4]) >> 2); - out[1] = (byte) ((in[1] + in[5] + in[nextrow+1] + in[nextrow+5]) >> 2); - out[2] = (byte) ((in[2] + in[6] + in[nextrow+2] + in[nextrow+6]) >> 2); - out[3] = (byte) ((in[3] + in[7] + in[nextrow+3] + in[nextrow+7]) >> 2); - out += 4; - in += 8; + Image_MipReduce(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1, glt->bytesperpixel); + prevbuffer = resizebuffer; + qglTexImage1D(GL_TEXTURE_1D, mip++, glt->glinternalformat, width, 0, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR } - in += nextrow; // skip a line } - } - else - { - // reduce width - width2 = width >> 1; - for (y = 0;y < height;y++) + break; + case GLTEXTURETYPE_2D: + qglTexImage2D(GL_TEXTURE_2D, mip++, glt->glinternalformat, width, height, 0, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR + if (glt->flags & TEXF_MIPMAP) { - for (x = 0;x < width2;x++) + while (width > 1 || height > 1 || depth > 1) { - out[0] = (byte) ((in[0] + in[4]) >> 1); - out[1] = (byte) ((in[1] + in[5]) >> 1); - out[2] = (byte) ((in[2] + in[6]) >> 1); - out[3] = (byte) ((in[3] + in[7]) >> 1); - out += 4; - in += 8; + Image_MipReduce(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1, glt->bytesperpixel); + prevbuffer = resizebuffer; + qglTexImage2D(GL_TEXTURE_2D, mip++, glt->glinternalformat, width, height, 0, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR } } - } - } - else - { - if (height > destheight) - { - // reduce height - height2 = height >> 1; - nextrow = width << 2; - for (y = 0;y < height2;y++) + break; + case GLTEXTURETYPE_3D: + qglTexImage3D(GL_TEXTURE_3D, mip++, glt->glinternalformat, width, height, depth, 0, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR + if (glt->flags & TEXF_MIPMAP) + { + while (width > 1 || height > 1 || depth > 1) + { + Image_MipReduce(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1, glt->bytesperpixel); + prevbuffer = resizebuffer; + qglTexImage3D(GL_TEXTURE_3D, mip++, glt->glinternalformat, width, height, depth, 0, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR + } + } + break; + case GLTEXTURETYPE_CUBEMAP: + // convert and upload each side in turn, + // from a continuous block of input texels + texturebuffer = prevbuffer; + for (i = 0;i < 6;i++) { - for (x = 0;x < width;x++) + prevbuffer = texturebuffer; + texturebuffer += glt->inputwidth * glt->inputheight * glt->inputdepth * glt->textype->inputbytesperpixel; + if (glt->inputwidth != width || glt->inputheight != height || glt->inputdepth != depth) { - out[0] = (byte) ((in[0] + in[nextrow ]) >> 1); - out[1] = (byte) ((in[1] + in[nextrow+1]) >> 1); - out[2] = (byte) ((in[2] + in[nextrow+2]) >> 1); - out[3] = (byte) ((in[3] + in[nextrow+3]) >> 1); - out += 4; - in += 4; + Image_Resample(prevbuffer, glt->inputwidth, glt->inputheight, glt->inputdepth, resizebuffer, width, height, depth, glt->bytesperpixel, r_lerpimages.integer); + prevbuffer = resizebuffer; + } + // picmip/max_size + while (width > glt->tilewidth || height > glt->tileheight || depth > glt->tiledepth) + { + Image_MipReduce(prevbuffer, resizebuffer, &width, &height, &depth, glt->tilewidth, glt->tileheight, glt->tiledepth, glt->bytesperpixel); + prevbuffer = resizebuffer; + } + mip = 0; + qglTexImage2D(cubemapside[i], mip++, glt->glinternalformat, width, height, 0, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR + if (glt->flags & TEXF_MIPMAP) + { + while (width > 1 || height > 1 || depth > 1) + { + Image_MipReduce(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1, glt->bytesperpixel); + prevbuffer = resizebuffer; + qglTexImage2D(cubemapside[i], mip++, glt->glinternalformat, width, height, 0, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR + } } - in += nextrow; // skip a line } + break; } - else - Sys_Error("GL_MipReduce: desired size already achieved\n"); + GL_SetupTextureParameters(glt->flags, glt->texturetype); } + qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR } -void GL_UploadTexture (gltexture_t *glt) +static void R_UploadTexture (gltexture_t *glt) { - int mip, width, height; - if (!r_upload.value) + if (!(glt->flags & GLTEXF_UPLOAD)) return; - glBindTexture(GL_TEXTURE_2D, glt->texnum); - width = glt->width; - height = glt->height; - for (mip = 0;mip < MAXMIPS && glt->texels[mip];mip++) - glTexImage2D(GL_TEXTURE_2D, mip, glt->alpha ? 4 : 3, glt->texelsize[mip][0], glt->texelsize[mip][1], 0, GL_RGBA, GL_UNSIGNED_BYTE, glt->texels[mip]); - if (glt->mipmap) - { - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); - } - else + + CHECKGLERROR + qglGenTextures(1, (GLuint *)&glt->texnum);CHECKGLERROR + R_Upload(glt, glt->inputtexels, 0, 0, 0, glt->inputwidth, glt->inputheight, glt->inputdepth); + if (glt->inputtexels) { - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + Mem_Free(glt->inputtexels); + glt->inputtexels = NULL; + glt->flags |= GLTEXF_DESTROYED; } - glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + else if (glt->flags & GLTEXF_DESTROYED) + Con_Printf("R_UploadTexture: Texture %s already uploaded and destroyed. Can not upload original image again. Uploaded blank texture.\n", glt->identifier); } -/* -================ -GL_LoadTexture -================ -*/ -int GL_LoadTexture (char *identifier, int width, int height, byte *data, qboolean mipmap, qboolean alpha, int bytesperpixel) +static rtexture_t *R_SetupTexture(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, int depth, int sides, int flags, int textype, int texturetype, const unsigned char *data, const unsigned int *palette) { - unsigned short crc; - int i, width2, height2, width3, height3, w, h, mip; - gltexture_t *glt; + int i, size; + gltexture_t *glt; + gltexturepool_t *pool = (gltexturepool_t *)rtexturepool; + textypeinfo_t *texinfo; - if (isDedicated) - return 1; + if (cls.state == ca_dedicated) + return NULL; - // LordHavoc: do a CRC to confirm the data really is the same as previous occurances. - crc = CRC_Block(data, width*height*bytesperpixel); - // see if the texture is already present - if (identifier[0]) + if (texturetype == GLTEXTURETYPE_CUBEMAP && !gl_texturecubemap) { - for (i=0, glt=gltextures ; iidentifier)) - { - // LordHavoc: everyone hates cache mismatchs, so I fixed it - if (crc != glt->crc || width != glt->width || height != glt->height) - { - Con_DPrintf("GL_LoadTexture: cache mismatch, replacing old texture\n"); - goto GL_LoadTexture_setup; // drop out with glt pointing to the texture to replace - //Sys_Error ("GL_LoadTexture: cache mismatch"); - } - if ((gl_lerpimages.value != 0) != glt->lerped) - goto GL_LoadTexture_setup; // drop out with glt pointing to the texture to replace - return glt->texnum; - } - } + Con_Printf ("R_LoadTexture: cubemap texture not supported by driver\n"); + return NULL; } - // LordHavoc: although this could be an else condition as it was in the original id code, - // it is more clear this way - // LordHavoc: check if there are still slots available - if (numgltextures >= MAX_GLTEXTURES) - Sys_Error ("GL_LoadTexture: ran out of texture slots (%d)\n", MAX_GLTEXTURES); - glt = &gltextures[numgltextures++]; - - strcpy (glt->identifier, identifier); - glt->texnum = texture_extension_number; - texture_extension_number++; -// LordHavoc: label to drop out of the loop into the setup code -GL_LoadTexture_setup: - // calculate power of 2 size - width2 = 1;while (width2 < width) width2 <<= 1; - height2 = 1;while (height2 < height) height2 <<= 1; - // calculate final size (mipmapped downward to this) - width3 = width2 >> (int) gl_picmip.value; - height3 = height2 >> (int) gl_picmip.value; - while (width3 > (int) gl_max_size.value) width3 >>= 1; - while (height3 > (int) gl_max_size.value) height3 >>= 1; - if (width3 < 1) width3 = 1; - if (height3 < 1) height3 = 1; - - // final storage - GL_AllocTexels(glt, width3, height3, mipmap); - glt->crc = crc; // LordHavoc: used to verify textures are identical - glt->width = width; - glt->height = height; - glt->mipmap = mipmap; - glt->bytesperpixel = bytesperpixel; - glt->lerped = gl_lerpimages.value != 0; - glt->alpha = false; // updated later - if (width == width3 && height == height3) // perfect match - { - if (bytesperpixel == 1) // 8bit - Image_Copy8bitRGBA(data, glt->texels[0], width*height, d_8to24table); - else - Image_CopyRGBAGamma(data, glt->texels[0], width*height); + if (texturetype == GLTEXTURETYPE_3D && !gl_texture3d) + { + Con_Printf ("R_LoadTexture: 3d texture not supported by driver\n"); + return NULL; } - else if (width == width2 && height == height2) // perfect match for top level, but needs to be reduced + + texinfo = R_GetTexTypeInfo(textype, flags); + size = width * height * depth * sides * texinfo->inputbytesperpixel; + if (size < 1) { - byte *temptexels2; - temptexels2 = malloc(width2*height2*4); // scaleup buffer - if (bytesperpixel == 1) // 8bit - Image_Copy8bitRGBA(data, temptexels2, width*height, d_8to24table); - else - Image_CopyRGBAGamma(data, temptexels2, width*height); - while (width2 > width3 || height2 > height3) - { - w = width2;h = height2; - if (width2 > width3) width2 >>= 1; - if (height2 > height3) height2 >>= 1; - if (width2 <= width3 && height2 <= height3) // size achieved - GL_MipReduce(temptexels2, glt->texels[0], w, h, width3, height3); - else - GL_MipReduce(temptexels2, temptexels2, w, h, width3, height3); - } - free(temptexels2); + Con_Printf ("R_LoadTexture: bogus texture size (%dx%dx%dx%dbppx%dsides = %d bytes)\n", width, height, depth, texinfo->inputbytesperpixel * 8, sides, size); + return NULL; } - else // scaling... + + // clear the alpha flag if the texture has no transparent pixels + switch(textype) { - byte *temptexels; - // pre-scaleup buffer - temptexels = malloc(width*height*4); - if (bytesperpixel == 1) // 8bit - Image_Copy8bitRGBA(data, temptexels, width*height, d_8to24table); - else - Image_CopyRGBAGamma(data, temptexels, width*height); - if (width2 != width3 || height2 != height3) // reduced by gl_pic_mip or gl_max_size + case TEXTYPE_PALETTE: + if (flags & TEXF_ALPHA) { - byte *temptexels2; - temptexels2 = malloc(width2*height2*4); // scaleup buffer - GL_ResampleTexture(temptexels, width, height, temptexels2, width2, height2); - while (width2 > width3 || height2 > height3) + flags &= ~TEXF_ALPHA; + if (data) { - w = width2;h = height2; - if (width2 > width3) width2 >>= 1; - if (height2 > height3) height2 >>= 1; - if (width2 <= width3 && height2 <= height3) // size achieved - GL_MipReduce(temptexels2, glt->texels[0], w, h, width3, height3); - else - GL_MipReduce(temptexels2, temptexels2, w, h, width3, height3); + for (i = 0;i < size;i++) + { + if (((unsigned char *)&palette[data[i]])[3] < 255) + { + flags |= TEXF_ALPHA; + break; + } + } } - free(temptexels2); } - else // copy directly - GL_ResampleTexture(temptexels, width, height, glt->texels[0], width2, height2); - free(temptexels); - } - if (alpha) - { - byte *in = glt->texels[0] + 3; - for (i = 0;i < width*height;i++, in += 4) - if (*in < 255) + break; + case TEXTYPE_RGB: + if (flags & TEXF_ALPHA) + Host_Error("R_LoadTexture: RGB has no alpha, don't specify TEXF_ALPHA"); + break; + case TEXTYPE_RGBA: + if (flags & TEXF_ALPHA) + { + flags &= ~TEXF_ALPHA; + if (data) { - glt->alpha = true; - break; + for (i = 3;i < size;i += 4) + { + if (data[i] < 255) + { + flags |= TEXF_ALPHA; + break; + } + } } + } + break; + default: + Host_Error("R_LoadTexture: unknown texture type"); + } + + glt = (gltexture_t *)Mem_Alloc(texturemempool, sizeof(gltexture_t)); + if (identifier) + strlcpy (glt->identifier, identifier, sizeof(glt->identifier)); + glt->pool = pool; + glt->chain = pool->gltchain; + pool->gltchain = glt; + glt->inputwidth = width; + glt->inputheight = height; + glt->inputdepth = depth; + glt->flags = flags | GLTEXF_UPLOAD; + glt->textype = texinfo; + glt->texturetype = texturetype; + glt->inputdatasize = size; + glt->palette = palette; + glt->glinternalformat = texinfo->glinternalformat; + glt->glformat = texinfo->glformat; + glt->bytesperpixel = texinfo->internalbytesperpixel; + glt->sides = glt->texturetype == GLTEXTURETYPE_CUBEMAP ? 6 : 1; + glt->texnum = -1; + + if (data) + { + glt->inputtexels = (unsigned char *)Mem_Alloc(texturemempool, size); + memcpy(glt->inputtexels, data, size); } - // this loop is skipped if there are no mipmaps to generate - for (mip = 1;mip < MAXMIPS && glt->texels[mip];mip++) - GL_MipReduce(glt->texels[mip-1], glt->texels[mip], glt->texelsize[mip-1][0], glt->texelsize[mip-1][1], 1, 1); - GL_UploadTexture(glt); + else + glt->inputtexels = NULL; -// if (bytesperpixel == 1) // 8bit -// GL_Upload8 (data, width, height, mipmap, alpha); -// else // 32bit -// GL_Upload32 (data, width, height, mipmap, true); + GL_Texture_CalcImageSize(glt->texturetype, glt->flags, glt->inputwidth, glt->inputheight, glt->inputdepth, &glt->tilewidth, &glt->tileheight, &glt->tiledepth); + R_PrecacheTexture(glt); - return glt->texnum; + return (rtexture_t *)glt; } -/* -================ -GL_LoadPicTexture -================ -*/ -int GL_LoadPicTexture (qpic_t *pic) +rtexture_t *R_LoadTexture1D(rtexturepool_t *rtexturepool, const char *identifier, int width, const unsigned char *data, int textype, int flags, const unsigned int *palette) { - return GL_LoadTexture ("", pic->width, pic->height, pic->data, false, true, 1); + return R_SetupTexture(rtexturepool, identifier, width, 1, 1, 1, flags, textype, GLTEXTURETYPE_1D, data, palette); } -int GL_GetTextureSlots (int count) +rtexture_t *R_LoadTexture2D(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, const unsigned char *data, int textype, int flags, const unsigned int *palette) { - gltexture_t *glt, *first; + return R_SetupTexture(rtexturepool, identifier, width, height, 1, 1, flags, textype, GLTEXTURETYPE_2D, data, palette); +} - first = glt = &gltextures[numgltextures]; - while (count--) - { - glt->identifier[0] = 0; - glt->texnum = texture_extension_number++; - glt->crc = 0; - glt->width = 0; - glt->height = 0; - glt->bytesperpixel = 0; - glt++; - numgltextures++; - } - return first->texnum; +rtexture_t *R_LoadTexture3D(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, int depth, const unsigned char *data, int textype, int flags, const unsigned int *palette) +{ + return R_SetupTexture(rtexturepool, identifier, width, height, depth, 1, flags, textype, GLTEXTURETYPE_3D, data, palette); +} + +rtexture_t *R_LoadTextureCubeMap(rtexturepool_t *rtexturepool, const char *identifier, int width, const unsigned char *data, int textype, int flags, const unsigned int *palette) +{ + return R_SetupTexture(rtexturepool, identifier, width, width, 1, 6, flags, textype, GLTEXTURETYPE_CUBEMAP, data, palette); } + +int R_TextureHasAlpha(rtexture_t *rt) +{ + return rt ? (((gltexture_t *)rt)->flags & TEXF_ALPHA) != 0 : false; +} + +int R_TextureWidth(rtexture_t *rt) +{ + return rt ? ((gltexture_t *)rt)->inputwidth : 0; +} + +int R_TextureHeight(rtexture_t *rt) +{ + return rt ? ((gltexture_t *)rt)->inputheight : 0; +} + +void R_UpdateTexture(rtexture_t *rt, unsigned char *data, int x, int y, int width, int height) +{ + gltexture_t *glt; + if (rt == NULL) + Host_Error("R_UpdateTexture: no texture supplied"); + if (data == NULL) + Host_Error("R_UpdateTexture: no data supplied"); + glt = (gltexture_t *)rt; + + // we need it to be uploaded before we can update a part of it + if (glt->flags & GLTEXF_UPLOAD) + R_UploadTexture(glt); + + // update part of the texture + R_Upload(glt, data, x, y, 0, width, height, 1); +} +