X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=gl_textures.c;h=e8476796cdacb73a09ed4883dff79be2f8db27ac;hp=7534ab4bd28ec00460eb42ea903550ffd49d9fa9;hb=f9d8bc7ea04ff91fcbd90fe50a299b37724b349b;hpb=855932aeb5707c5efb2858c3e51b913d8203ebbe diff --git a/gl_textures.c b/gl_textures.c index 7534ab4b..e8476796 100644 --- a/gl_textures.c +++ b/gl_textures.c @@ -1,924 +1,1270 @@ + #include "quakedef.h" +#include "image.h" +#include "jpeg.h" + +cvar_t gl_max_size = {CVAR_SAVE, "gl_max_size", "2048"}; +cvar_t gl_max_scrapsize = {CVAR_SAVE, "gl_max_scrapsize", "256"}; +cvar_t gl_picmip = {CVAR_SAVE, "gl_picmip", "0"}; +cvar_t r_lerpimages = {CVAR_SAVE, "r_lerpimages", "1"}; +cvar_t r_precachetextures = {CVAR_SAVE, "r_precachetextures", "1"}; +cvar_t gl_texture_anisotropy = {CVAR_SAVE, "gl_texture_anisotropy", "1"}; -cvar_t gl_max_size = {"gl_max_size", "1024"}; -cvar_t gl_picmip = {"gl_picmip", "0"}; -cvar_t gl_lerpimages = {"gl_lerpimages", "1"}; +int gl_filter_min = GL_LINEAR_MIPMAP_LINEAR; +int gl_filter_mag = GL_LINEAR; -int gl_filter_min = GL_LINEAR_MIPMAP_LINEAR; //NEAREST; -int gl_filter_max = GL_LINEAR; +static mempool_t *texturemempool; -int texels; +// 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 -// 4096x4096 -#define MAXMIPS 12 +// size of images which hold fragment textures, ignores picmip and max_size +static int block_size; -typedef struct +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}; +static textypeinfo_t textype_dsdt = {TEXTYPE_DSDT , 2, 2, GL_DSDT_NV, GL_DSDT8_NV}; + +// a tiling texture (most common type) +#define GLIMAGETYPE_TILE 0 +// a fragments texture (contains one or more fragment textures) +#define GLIMAGETYPE_FRAGMENTS 1 + +#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] = { - 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; + 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 +}; -#define MAX_GLTEXTURES 4096 -gltexture_t gltextures[MAX_GLTEXTURES]; -int numgltextures; +// a gltextureimage can have one (or more if fragments) gltextures inside +typedef struct gltextureimage_s +{ + struct gltextureimage_s *imagechain; + int texturecount; + int type; // one of the GLIMAGETYPE_ values + int texturetype; // one of the GLTEXTURETYPE_ values + int sides; // 1 or 6 depending on texturetype + int texnum; // GL texture slot number + int width, height, depth; // 3D texture support + int bytesperpixel; // bytes per pixel + int glformat; // GL_RGB or GL_RGBA + int glinternalformat; // 3 or 4 + int flags; + short *blockallocation; // fragment allocation (2D only) +} +gltextureimage_t; -typedef struct +typedef struct gltexture_s { - char *name; - int minimize, maximize; -} glmode_t; + // 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; + // pointer into gltextureimage array + gltextureimage_t *image; + // name of the texture (this might be removed someday), no duplicates + char identifier[32]; + // location in the image, and size + int x, y, z, width, height, depth; + // copy of the original texture(s) supplied to the upload function, for + // delayed uploads (non-precached) + qbyte *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; +} +gltexture_t; -glmode_t modes[] = { - {"GL_NEAREST", GL_NEAREST, GL_NEAREST}, - {"GL_LINEAR", GL_LINEAR, GL_LINEAR}, - {"GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST}, - {"GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR}, - {"GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST}, - {"GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR} -}; +#define TEXTUREPOOL_SENTINEL 0xC0DEDBAD -/* -=============== -Draw_TextureMode_f -=============== -*/ -void Draw_TextureMode_f (void) +typedef struct gltexturepool_s { - int i; - gltexture_t *glt; + unsigned int sentinel; + struct gltextureimage_s *imagechain; + struct gltexture_s *gltchain; + struct gltexturepool_s *next; +} +gltexturepool_t; - if (Cmd_Argc() == 1) - { - for (i=0 ; i< 6 ; i++) - if (gl_filter_min == modes[i].minimize) - { - Con_Printf ("%s\n", modes[i].name); - return; - } - Con_Printf ("current filter is unknown???\n"); - return; - } +static gltexturepool_t *gltexturepoolchain = NULL; - for (i=0 ; i< 6 ; i++) - { - if (!Q_strcasecmp (modes[i].name, Cmd_Argv(1) ) ) - break; - } - if (i == 6) - { - Con_Printf ("bad filter name\n"); - return; - } +static qbyte *resizebuffer = NULL, *colorconvertbuffer; +static int resizebuffersize = 0; +static qbyte *texturebuffer; +static int texturebuffersize = 0; - gl_filter_min = modes[i].minimize; - gl_filter_max = modes[i].maximize; +static int realmaxsize = 0; - // change all the existing mipmap texture objects - for (i=0, glt=gltextures ; imipmap) + switch(textype) { - 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); + case TEXTYPE_PALETTE: + return &textype_palette; + case TEXTYPE_RGB: + return &textype_rgb; + case TEXTYPE_RGBA: + return &textype_rgba; + case TEXTYPE_DSDT: + return &textype_dsdt; + default: + Host_Error("R_GetTexTypeInfo: unknown texture format\n"); + return NULL; } } } -extern int buildnumber; - -char engineversion[40]; +static void R_UploadTexture(gltexture_t *t); -void GL_UploadTexture (gltexture_t *glt); -void gl_textures_start() +static void R_PrecacheTexture(gltexture_t *glt) { - int i; - gltexture_t *glt; - for (i=0, glt=gltextures ; iflags & 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); } -void gl_textures_shutdown() +int R_RealGetTexture(rtexture_t *rt) { + if (rt) + { + gltexture_t *glt; + glt = (gltexture_t *)rt; + if (glt->flags & GLTEXF_UPLOAD) + R_UploadTexture(glt); + glt->texnum = glt->image->texnum; + return glt->image->texnum; + } + else + return 0; } -void GL_Textures_Init (void) +void R_FreeTexture(rtexture_t *rt) { - Cvar_RegisterVariable (&gl_max_size); - Cvar_RegisterVariable (&gl_picmip); - Cvar_RegisterVariable (&gl_lerpimages); + gltexture_t *glt, **gltpointer; + gltextureimage_t *image, **gltimagepointer; + + glt = (gltexture_t *)rt; + if (glt == NULL) + Host_Error("R_FreeTexture: texture == NULL\n"); - // 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"); + 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\n", glt->identifier); - Cmd_AddCommand ("gl_texturemode", &Draw_TextureMode_f); + // note: if freeing a fragment texture, this will not make the claimed + // space available for new textures unless all other fragments in the + // image are also freed + if (glt->image) + { + image = glt->image; + image->texturecount--; + if (image->texturecount < 1) + { + for (gltimagepointer = &glt->pool->imagechain;*gltimagepointer && *gltimagepointer != image;gltimagepointer = &(*gltimagepointer)->imagechain); + if (*gltimagepointer == image) + *gltimagepointer = image->imagechain; + else + Host_Error("R_FreeTexture: image not linked in pool\n"); + if (image->texnum) + qglDeleteTextures(1, (GLuint *)&image->texnum); + if (image->blockallocation) + Mem_Free(image->blockallocation); + Mem_Free(image); + } + } - R_RegisterModule("GL_Textures", gl_textures_start, gl_textures_shutdown); + if (glt->inputtexels) + Mem_Free(glt->inputtexels); + Mem_Free(glt); } -/* -================ -GL_FindTexture -================ -*/ -int GL_FindTexture (char *identifier) +rtexturepool_t *R_AllocTexturePool(void) { - int i; - gltexture_t *glt; + 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; +} - for (i=0, glt=gltextures ; iidentifier)) - return gltextures[i].texnum; - } +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\n"); + for (poolpointer = &gltexturepoolchain;*poolpointer && *poolpointer != pool;poolpointer = &(*poolpointer)->next); + if (*poolpointer == pool) + *poolpointer = pool->next; + else + Host_Error("R_FreeTexturePool: pool not linked\n"); + while (pool->gltchain) + R_FreeTexture((rtexture_t *)pool->gltchain); + if (pool->imagechain) + Con_Printf("R_FreeTexturePool: not all images freed\n"); + Mem_Free(pool); +} - return -1; + +typedef struct glmode_s +{ + char *name; + int minification, magnification; } +glmode_t; -extern byte qgamma[]; +static glmode_t modes[] = +{ + {"GL_NEAREST", GL_NEAREST, GL_NEAREST}, + {"GL_LINEAR", GL_LINEAR, GL_LINEAR}, + {"GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST}, + {"GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR}, + {"GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST}, + {"GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR} +}; -// LordHavoc: gamma correction and improved resampling -void GL_ResampleTextureLerpLine (byte *in, byte *out, int inwidth, int outwidth) +static void GL_TextureMode_f (void) { - 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) + int i; + GLint oldbindtexnum; + gltextureimage_t *image; + gltexturepool_t *pool; + + if (Cmd_Argc() == 1) { - xi = (int) f >> 16; - if (xi != oldx) - { - in += (xi - oldx) * 4; - oldx = xi; - } - if (xi < endx) - { - l2 = f & 0xFFFF; - l1 = 0x10000 - l2; - *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) ; - } - else // last pixel of the line has no pixel to lerp to + for (i = 0;i < 6;i++) { - *out++ = qgamma[in[0]]; - *out++ = qgamma[in[1]]; - *out++ = qgamma[in[2]]; - *out++ = in[3] ; + if (gl_filter_min == modes[i].minification) + { + Con_Printf("%s\n", modes[i].name); + return; + } } + Con_Print("current filter is unknown???\n"); + return; } -} -/* -================ -GL_ResampleTexture -================ -*/ -void GL_ResampleTexture (void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight) -{ - // LordHavoc: gamma correction and greatly improved resampling - if (gl_lerpimages.value) + for (i = 0;i < 6;i++) + if (!strcasecmp (modes[i].name, Cmd_Argv(1) ) ) + break; + if (i == 6) { - 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); + Con_Print("bad filter name\n"); + return; + } + + gl_filter_min = modes[i].minification; + gl_filter_mag = modes[i].magnification; - 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) + // change all the existing mipmap texture objects + // FIXME: force renderer(/client/something?) restart instead? + for (pool = gltexturepoolchain;pool;pool = pool->next) + { + for (image = pool->imagechain;image;image = image->imagechain) { - yi = f >> 16; - if (yi != oldy) + // only update already uploaded images + if (!(image->flags & GLTEXF_UPLOAD) && !(image->flags & (TEXF_FORCENEAREST | TEXF_FORCELINEAR))) { - 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); + qglGetIntegerv(gltexturetypebindingenums[image->texturetype], &oldbindtexnum); + qglBindTexture(gltexturetypeenums[image->texturetype], image->texnum); + if (image->flags & TEXF_MIPMAP) + qglTexParameteri(gltexturetypeenums[image->texturetype], GL_TEXTURE_MIN_FILTER, gl_filter_min); 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; + qglTexParameteri(gltexturetypeenums[image->texturetype], GL_TEXTURE_MIN_FILTER, gl_filter_mag); + qglTexParameteri(gltexturetypeenums[image->texturetype], GL_TEXTURE_MAG_FILTER, gl_filter_mag); + qglBindTexture(gltexturetypeenums[image->texturetype], oldbindtexnum); } } - free(row1); - free(row2); } +} + +static int R_CalcTexelDataSize (gltexture_t *glt) +{ + int width2, height2, depth2, size, picmip; + if (glt->flags & TEXF_FRAGMENT) + size = glt->width * glt->height * glt->depth; else { - int i, j; - unsigned frac, fracstep; - byte *inrow, *out, *inpix; - out = outdata; + picmip = 0; + if (glt->flags & TEXF_PICMIP) + picmip = gl_picmip.integer; + if (gl_max_size.integer > realmaxsize) + Cvar_SetValue("gl_max_size", realmaxsize); + // calculate final size + for (width2 = 1;width2 < glt->width;width2 <<= 1); + for (height2 = 1;height2 < glt->height;height2 <<= 1); + for (depth2 = 1;depth2 < glt->depth;depth2 <<= 1); + for (width2 >>= picmip;width2 > gl_max_size.integer;width2 >>= 1); + for (height2 >>= picmip;height2 > gl_max_size.integer;height2 >>= 1); + for (depth2 >>= picmip;depth2 > gl_max_size.integer;depth2 >>= 1); + if (width2 < 1) width2 = 1; + if (height2 < 1) height2 = 1; + if (depth2 < 1) depth2 = 1; - fracstep = inwidth*0x10000/outwidth; - for (i=0 ; iflags & TEXF_MIPMAP) { - inrow = (byte *)indata + inwidth*(i*inheight/outheight)*4; - frac = fracstep >> 1; - for (j=0 ; j 1 || height2 > 1 || depth2 > 1) { - 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; + size += width2 * height2 * depth2; + if (width2 > 1) + width2 >>= 1; + if (height2 > 1) + height2 >>= 1; + if (depth2 > 1) + depth2 >>= 1; } + size++; // count the last 1x1 mipmap } + else + size = width2 * height2 * depth2; } + size *= glt->textype->internalbytesperpixel * glt->image->sides; + + return size; } -/* -================ -GL_Resample8BitTexture -- JACK -================ -*/ -/* -void GL_Resample8BitTexture (unsigned char *in, int inwidth, int inheight, unsigned char *out, int outwidth, int outheight) +void R_TextureStats_Print(qboolean printeach, qboolean printpool, qboolean printtotal) { - int i, j; - unsigned char *inrow; - unsigned frac, fracstep; - - fracstep = inwidth*0x10000/outwidth; - for (i=0 ; inext) { - inrow = in + inwidth*(i*inheight/outheight); - frac = fracstep >> 1; - for (j=0 ; jgltchain;glt;glt = glt->chain) { - out[j ] = inrow[frac>>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; + glsize = R_CalcTexelDataSize(glt); + isloaded = !(glt->flags & GLTEXF_UPLOAD); + pooltotal++; + pooltotalt += glsize; + pooltotalp += glt->inputdatasize; + if (isloaded) + { + 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); } -*/ +static void R_TextureStats_f(void) +{ + R_TextureStats_Print(true, true, true); +} -/* -================ -GL_MipMap - -Operates in place, quartering the size of the texture -================ -*/ -/* -void GL_MipMap (byte *in, int width, int height) +static void r_textures_start(void) { - int i, j; - byte *out; + // deal with size limits of various drivers (3dfx in particular) + qglGetIntegerv(GL_MAX_TEXTURE_SIZE, &realmaxsize); + CHECKGLERROR + // LordHavoc: allow any alignment + qglPixelStorei(GL_UNPACK_ALIGNMENT, 1); + CHECKGLERROR - 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; - } - } -} -*/ + // use the largest scrap texture size we can (not sure if this is really a good idea) + for (block_size = 1;block_size < realmaxsize && block_size < gl_max_scrapsize.integer;block_size <<= 1); -/* -================ -GL_MipMap8Bit + texturemempool = Mem_AllocPool("texture management", 0, NULL); + + // Disable JPEG screenshots if the DLL isn't loaded + if (! JPEG_OpenLibrary ()) + Cvar_SetValueQuick (&scr_screenshot_jpeg, 0); +} -Mipping for 8 bit textures -================ -*/ -/* -void GL_MipMap8Bit (byte *in, int width, int height) +static void r_textures_shutdown(void) { - int i, j; - unsigned short r,g,b; - byte *out, *at1, *at2, *at3, *at4; + rtexturepool_t *temp; - height >>= 1; - out = in; - for (i=0 ; i>=5; - g = (at1[1]+at2[1]+at3[1]+at4[1]); g>>=5; - b = (at1[2]+at2[2]+at3[2]+at4[2]); b>>=5; + resizebuffersize = 0; + texturebuffersize = 0; + resizebuffer = NULL; + colorconvertbuffer = NULL; + texturebuffer = NULL; + Mem_FreePool(&texturemempool); +} - out[0] = d_15to8table[(r<<0) + (g<<5) + (b<<10)]; - } - } +static void r_textures_newmap(void) +{ } -*/ -/* -=============== -GL_Upload32 -=============== -*/ -/* -void GL_Upload32 (void *data, int width, int height, qboolean mipmap, qboolean alpha) +void R_Textures_Init (void) { - int samples, scaled_width, scaled_height, i; - byte *in, *out, *scaled; + Cmd_AddCommand("gl_texturemode", &GL_TextureMode_f); + Cmd_AddCommand("r_texturestats", R_TextureStats_f); + Cvar_RegisterVariable (&gl_max_scrapsize); + Cvar_RegisterVariable (&gl_max_size); + Cvar_RegisterVariable (&gl_picmip); + Cvar_RegisterVariable (&r_lerpimages); + Cvar_RegisterVariable (&r_precachetextures); + Cvar_RegisterVariable (&gl_texture_anisotropy); - for (scaled_width = 1 ; scaled_width < width ; scaled_width<<=1) - ; - for (scaled_height = 1 ; scaled_height < height ; scaled_height<<=1) - ; + R_RegisterModule("R_Textures", r_textures_start, r_textures_shutdown, r_textures_newmap); +} - scaled_width >>= (int)gl_picmip.value; - scaled_height >>= (int)gl_picmip.value; +void R_Textures_Frame (void) +{ + static int old_aniso = 0; - 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; + // could do procedural texture animation here, if we keep track of which + // textures were accessed this frame... - if (alpha) + // free the resize buffers + resizebuffersize = 0; + if (resizebuffer) { - alpha = false; - in = data; - for (i = 3;i < width*height*4;i += 4) - if (in[i] != 255) - { - alpha = true; - break; - } + Mem_Free(resizebuffer); + resizebuffer = NULL; } - - 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) + if (colorconvertbuffer) { - // 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++; - } + Mem_Free(colorconvertbuffer); + colorconvertbuffer = NULL; } - 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) + if (old_aniso != gl_texture_anisotropy.integer) { - int miplevel; + gltextureimage_t *image; + gltexturepool_t *pool; + GLint oldbindtexnum; + + old_aniso = bound(1, gl_texture_anisotropy.integer, gl_max_anisotropy); - miplevel = 0; - while (scaled_width > 1 || scaled_height > 1) + Cvar_SetValueQuick(&gl_texture_anisotropy, old_aniso); + + for (pool = gltexturepoolchain;pool;pool = pool->next) { - 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); + for (image = pool->imagechain;image;image = image->imagechain) + { + // only update already uploaded images + if (!(image->flags & GLTEXF_UPLOAD) && (image->flags & TEXF_MIPMAP)) + { + qglGetIntegerv(gltexturetypebindingenums[image->texturetype], &oldbindtexnum); + + qglBindTexture(gltexturetypeenums[image->texturetype], image->texnum); + qglTexParameteri(gltexturetypeenums[image->texturetype], GL_TEXTURE_MAX_ANISOTROPY_EXT, old_aniso);CHECKGLERROR + + qglBindTexture(gltexturetypeenums[image->texturetype], oldbindtexnum); + } + } } } +} - if (mipmap) - { - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); - } - else +void R_MakeResizeBufferBigger(int size) +{ + if (resizebuffersize < size) { - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + resizebuffersize = size; + if (resizebuffer) + Mem_Free(resizebuffer); + if (colorconvertbuffer) + Mem_Free(colorconvertbuffer); + resizebuffer = (qbyte *)Mem_Alloc(texturemempool, resizebuffersize); + colorconvertbuffer = (qbyte *)Mem_Alloc(texturemempool, resizebuffersize); + if (!resizebuffer || !colorconvertbuffer) + Host_Error("R_Upload: out of memory\n"); } - free(scaled); } -void GL_Upload8_EXT (byte *data, int width, int height, qboolean mipmap) +static void GL_SetupTextureParameters(int flags, int texturetype) { - int scaled_width, scaled_height; - byte *scaled = NULL; - - for (scaled_width = 1 ; scaled_width < width ; scaled_width<<=1) - ; - for (scaled_height = 1 ; scaled_height < height ; scaled_height<<=1) - ; - - scaled_width >>= (int)gl_picmip.value; - scaled_height >>= (int)gl_picmip.value; + 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 - texels += scaled_width * scaled_height; - - if (scaled_width == width && scaled_height == height) + if (gl_support_anisotropy && (flags & TEXF_MIPMAP)) { - 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); + 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 } - else + qglTexParameteri(textureenum, GL_TEXTURE_WRAP_S, wrapmode);CHECKGLERROR + qglTexParameteri(textureenum, GL_TEXTURE_WRAP_T, wrapmode);CHECKGLERROR + if (gltexturetypedimensions[texturetype] >= 3) { - scaled = malloc(scaled_width*scaled_height*4); - GL_Resample8BitTexture (data, width, height, (void*) scaled, scaled_width, scaled_height); + qglTexParameteri(textureenum, GL_TEXTURE_WRAP_R, wrapmode);CHECKGLERROR } - glTexImage2D (GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT, scaled_width, scaled_height, 0, GL_COLOR_INDEX, 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) + { + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);CHECKGLERROR + } + else { - 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); + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_NEAREST);CHECKGLERROR } + qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, GL_NEAREST);CHECKGLERROR } -done: ; - - - 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); -} -*/ -extern qboolean VID_Is8bit(); + CHECKGLERROR +} -/* -=============== -GL_Upload8 -=============== -*/ -/* -void GL_Upload8 (byte *data, int width, int height, qboolean mipmap, qboolean alpha) +static void R_Upload(gltexture_t *glt, qbyte *data) { - static unsigned *trans; - int i, s; - qboolean noalpha; - int p; - byte *indata; - int *outdata; + int i, mip, width, height, depth; + GLint oldbindtexnum; + qbyte *prevbuffer; + prevbuffer = data; + + CHECKGLERROR - 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) + glt->texnum = glt->image->texnum; + // we need to restore the texture binding after finishing the upload + qglGetIntegerv(gltexturetypebindingenums[glt->image->texturetype], &oldbindtexnum); + qglBindTexture(gltexturetypeenums[glt->image->texturetype], glt->image->texnum); + CHECKGLERROR + glt->flags &= ~GLTEXF_UPLOAD; + + if (glt->flags & TEXF_FRAGMENT) { - noalpha = true; - for (i=0 ; iimage->flags & GLTEXF_UPLOAD) { - p = data[i]; - if (p != 255) - trans[i] = d_8to24table[p]; - else + glt->image->flags &= ~GLTEXF_UPLOAD; + Con_DPrint("uploaded new fragments image\n"); + R_MakeResizeBufferBigger(glt->image->width * glt->image->height * glt->image->depth * glt->image->bytesperpixel); + memset(resizebuffer, 255, glt->image->width * glt->image->height * glt->image->depth * glt->image->bytesperpixel); + switch(glt->image->texturetype) { - trans[i] = 0; // force to black - noalpha = false; + case GLTEXTURETYPE_1D: + qglTexImage1D(GL_TEXTURE_1D, 0, glt->image->glinternalformat, glt->image->width, 0, glt->image->glformat, GL_UNSIGNED_BYTE, resizebuffer); + CHECKGLERROR + break; + case GLTEXTURETYPE_2D: + qglTexImage2D(GL_TEXTURE_2D, 0, glt->image->glinternalformat, glt->image->width, glt->image->height, 0, glt->image->glformat, GL_UNSIGNED_BYTE, resizebuffer); + CHECKGLERROR + break; + case GLTEXTURETYPE_3D: + qglTexImage3D(GL_TEXTURE_3D, 0, glt->image->glinternalformat, glt->image->width, glt->image->height, glt->image->depth, 0, glt->image->glformat, GL_UNSIGNED_BYTE, resizebuffer); + CHECKGLERROR + break; + default: + Host_Error("R_Upload: fragment texture of type other than 1D, 2D, or 3D\n"); + break; } + GL_SetupTextureParameters(glt->image->flags, glt->image->texturetype); } - if (noalpha) + if (prevbuffer == NULL) { - if (VID_Is8bit() && (data!=scrap_texels[0])) - { - GL_Upload8_EXT (data, width, height, mipmap); - free(trans); - return; - } - alpha = false; + R_MakeResizeBufferBigger(glt->image->width * glt->image->height * glt->image->depth * glt->image->bytesperpixel); + memset(resizebuffer, 0, glt->width * glt->height * glt->image->depth * glt->image->bytesperpixel); + prevbuffer = resizebuffer; + } + else if (glt->textype->textype == TEXTYPE_PALETTE) + { + // promote paletted to RGBA, so we only have to worry about RGB and + // RGBA in the rest of this code + R_MakeResizeBufferBigger(glt->image->width * glt->image->height * glt->image->depth * glt->image->sides * glt->image->bytesperpixel); + Image_Copy8bitRGBA(prevbuffer, colorconvertbuffer, glt->width * glt->height * glt->depth, glt->palette); + prevbuffer = colorconvertbuffer; + } + + switch(glt->image->texturetype) + { + case GLTEXTURETYPE_1D: + qglTexSubImage1D(GL_TEXTURE_1D, 0, glt->x, glt->width, glt->image->glformat, GL_UNSIGNED_BYTE, prevbuffer); + CHECKGLERROR + break; + case GLTEXTURETYPE_2D: + qglTexSubImage2D(GL_TEXTURE_2D, 0, glt->x, glt->y, glt->width, glt->height, glt->image->glformat, GL_UNSIGNED_BYTE, prevbuffer); + CHECKGLERROR + break; + case GLTEXTURETYPE_3D: + qglTexSubImage3D(GL_TEXTURE_3D, 0, glt->x, glt->y, glt->z, glt->width, glt->height, glt->depth, glt->image->glformat, GL_UNSIGNED_BYTE, prevbuffer); + CHECKGLERROR + break; + default: + Host_Error("R_Upload: fragment texture of type other than 1D, 2D, or 3D\n"); + break; } } else { - // LordHavoc: dodge the copy if it will be uploaded as 8bit - if (VID_Is8bit() && (data!=scrap_texels[0])) + glt->image->flags &= ~GLTEXF_UPLOAD; + + // these are rounded up versions of the size to do better resampling + for (width = 1;width < glt->width ;width <<= 1); + for (height = 1;height < glt->height;height <<= 1); + for (depth = 1;depth < glt->depth ;depth <<= 1); + + R_MakeResizeBufferBigger(width * height * depth * glt->image->sides * glt->image->bytesperpixel); + + if (prevbuffer == NULL) { - GL_Upload8_EXT (data, width, height, mipmap); - free(trans); - return; + width = glt->image->width; + height = glt->image->height; + depth = glt->image->depth; + memset(resizebuffer, 0, width * height * depth * glt->image->bytesperpixel); + prevbuffer = resizebuffer; } - //if (s&3) - // Sys_Error ("GL_Upload8: s&3"); - indata = data; - outdata = trans; - if (s&1) - *outdata++ = d_8to24table[*indata++]; - if (s&2) + else { - *outdata++ = d_8to24table[*indata++]; - *outdata++ = d_8to24table[*indata++]; + if (glt->textype->textype == TEXTYPE_PALETTE) + { + // promote paletted to RGBA, so we only have to worry about RGB and + // RGBA in the rest of this code + Image_Copy8bitRGBA(prevbuffer, colorconvertbuffer, glt->width * glt->height * glt->depth * glt->image->sides, glt->palette); + prevbuffer = colorconvertbuffer; + } } - for (i = 0;i < s;i+=4) + + // cubemaps contain multiple images and thus get processed a bit differently + if (glt->image->texturetype != GLTEXTURETYPE_CUBEMAP) { - *outdata++ = d_8to24table[*indata++]; - *outdata++ = d_8to24table[*indata++]; - *outdata++ = d_8to24table[*indata++]; - *outdata++ = d_8to24table[*indata++]; + if (glt->width != width || glt->height != height || glt->depth != depth) + { + Image_Resample(prevbuffer, glt->width, glt->height, glt->depth, resizebuffer, width, height, depth, glt->image->bytesperpixel, r_lerpimages.integer); + prevbuffer = resizebuffer; + } + // picmip/max_size + while (width > glt->image->width || height > glt->image->height || depth > glt->image->depth) + { + Image_MipReduce(prevbuffer, resizebuffer, &width, &height, &depth, glt->image->width, glt->image->height, glt->image->depth, glt->image->bytesperpixel); + prevbuffer = resizebuffer; + } } - } - - GL_Upload32 (trans, width, height, mipmap, alpha); - free(trans); -} -*/ - -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++) + mip = 0; + switch(glt->image->texturetype) { - glt->texelsize[i][0] = w; - glt->texelsize[i][1] = h; - glt->texels[i] = (void *)size; - size += w*h*4; - if (w > 1) + case GLTEXTURETYPE_1D: + qglTexImage1D(GL_TEXTURE_1D, mip++, glt->image->glinternalformat, width, 0, glt->image->glformat, GL_UNSIGNED_BYTE, prevbuffer); + CHECKGLERROR + if (glt->flags & TEXF_MIPMAP) { - w >>= 1; - if (h > 1) - h >>= 1; + while (width > 1 || height > 1 || depth > 1) + { + Image_MipReduce(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1, glt->image->bytesperpixel); + prevbuffer = resizebuffer; + qglTexImage1D(GL_TEXTURE_1D, mip++, glt->image->glinternalformat, width, 0, glt->image->glformat, GL_UNSIGNED_BYTE, prevbuffer); + CHECKGLERROR + } } - else if (h > 1) - h >>= 1; - else + break; + case GLTEXTURETYPE_2D: + qglTexImage2D(GL_TEXTURE_2D, mip++, glt->image->glinternalformat, width, height, 0, glt->image->glformat, GL_UNSIGNED_BYTE, prevbuffer); + CHECKGLERROR + if (glt->flags & TEXF_MIPMAP) { - i++; - break; + while (width > 1 || height > 1 || depth > 1) + { + Image_MipReduce(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1, glt->image->bytesperpixel); + prevbuffer = resizebuffer; + qglTexImage2D(GL_TEXTURE_2D, mip++, glt->image->glinternalformat, width, height, 0, glt->image->glformat, GL_UNSIGNED_BYTE, prevbuffer); + CHECKGLERROR + } + } + break; + case GLTEXTURETYPE_3D: + qglTexImage3D(GL_TEXTURE_3D, mip++, glt->image->glinternalformat, width, height, depth, 0, glt->image->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->image->bytesperpixel); + prevbuffer = resizebuffer; + qglTexImage3D(GL_TEXTURE_3D, mip++, glt->image->glinternalformat, width, height, depth, 0, glt->image->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++) + { + prevbuffer = texturebuffer; + texturebuffer += glt->width * glt->height * glt->depth * glt->textype->inputbytesperpixel; + if (glt->width != width || glt->height != height || glt->depth != depth) + { + Image_Resample(prevbuffer, glt->width, glt->height, glt->depth, resizebuffer, width, height, depth, glt->image->bytesperpixel, r_lerpimages.integer); + prevbuffer = resizebuffer; + } + // picmip/max_size + while (width > glt->image->width || height > glt->image->height || depth > glt->image->depth) + { + Image_MipReduce(prevbuffer, resizebuffer, &width, &height, &depth, glt->image->width, glt->image->height, glt->image->depth, glt->image->bytesperpixel); + prevbuffer = resizebuffer; + } + mip = 0; + qglTexImage2D(cubemapside[i], mip++, glt->image->glinternalformat, width, height, 0, glt->image->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->image->bytesperpixel); + prevbuffer = resizebuffer; + qglTexImage2D(cubemapside[i], mip++, glt->image->glinternalformat, width, height, 0, glt->image->glformat, GL_UNSIGNED_BYTE, prevbuffer); + CHECKGLERROR + } + } + } + break; } - 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]; + GL_SetupTextureParameters(glt->image->flags, glt->image->texturetype); } - 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"); + qglBindTexture(gltexturetypeenums[glt->image->texturetype], oldbindtexnum); } -// in can be the same as out -void GL_MipReduce(byte *in, byte *out, int width, int height, int destwidth, int destheight) +static void R_FindImageForTexture(gltexture_t *glt) { - int x, y, width2, height2, nextrow; - if (width > destwidth) + int i, j, best, best2, x, y, z, w, h, d, picmip; + textypeinfo_t *texinfo; + gltexturepool_t *pool; + gltextureimage_t *image, **imagechainpointer; + texinfo = glt->textype; + pool = glt->pool; + + // remains -1 until uploaded + glt->texnum = -1; + + x = 0; + y = 0; + z = 0; + w = glt->width; + h = glt->height; + d = glt->depth; + if (glt->flags & TEXF_FRAGMENT) { - if (height > destheight) + for (imagechainpointer = &pool->imagechain;*imagechainpointer;imagechainpointer = &(*imagechainpointer)->imagechain) { - // reduce both - width2 = width >> 1; - height2 = height >> 1; - nextrow = width << 2; - for (y = 0;y < height2;y++) + image = *imagechainpointer; + if (image->type != GLIMAGETYPE_FRAGMENTS) + continue; + if (image->texturetype != glt->texturetype) + continue; + if ((image->flags ^ glt->flags) & (TEXF_MIPMAP | TEXF_ALPHA | TEXF_CLAMP | TEXF_FORCENEAREST | TEXF_FORCELINEAR)) + continue; + if (image->glformat != texinfo->glformat || image->glinternalformat != texinfo->glinternalformat) + continue; + if (glt->width > image->width || glt->height > image->height || glt->depth > image->depth) + continue; + + // got a fragments texture, find a place in it if we can + for (best = image->width, i = 0;i < image->width - w;i++) { - for (x = 0;x < width2;x++) + for (best2 = 0, j = 0;j < w;j++) { - 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; + if (image->blockallocation[i+j] >= best) + break; + if (best2 < image->blockallocation[i+j]) + best2 = image->blockallocation[i+j]; } - in += nextrow; // skip a line - } - } - else - { - // reduce width - width2 = width >> 1; - for (y = 0;y < height;y++) - { - for (x = 0;x < width2;x++) + if (j == w) { - 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; + // this is a valid spot + x = i; + y = best = best2; } } + + if (best + h > image->height) + continue; + + for (i = 0;i < w;i++) + image->blockallocation[x + i] = best + h; + + glt->x = x; + glt->y = y; + glt->z = 0; + glt->image = image; + image->texturecount++; + return; } + + image = (gltextureimage_t *)Mem_Alloc(texturemempool, sizeof(gltextureimage_t)); + if (image == NULL) + { + Con_Printf ("R_FindImageForTexture: ran out of memory\n"); + return; + } + image->type = GLIMAGETYPE_FRAGMENTS; + // make sure the created image is big enough for the fragment + for (image->width = block_size;image->width < glt->width;image->width <<= 1); + image->height = 1; + if (gltexturetypedimensions[glt->texturetype] >= 2) + for (image->height = block_size;image->height < glt->height;image->height <<= 1); + image->depth = 1; + if (gltexturetypedimensions[glt->texturetype] >= 3) + for (image->depth = block_size;image->depth < glt->depth;image->depth <<= 1); + image->blockallocation = (short int *)Mem_Alloc(texturemempool, image->width * sizeof(short)); + memset(image->blockallocation, 0, image->width * sizeof(short)); + + x = 0; + y = 0; + z = 0; + for (i = 0;i < w;i++) + image->blockallocation[x + i] = y + h; } else { - if (height > destheight) + for (imagechainpointer = &pool->imagechain;*imagechainpointer;imagechainpointer = &(*imagechainpointer)->imagechain); + + image = (gltextureimage_t *)Mem_Alloc(texturemempool, sizeof(gltextureimage_t)); + if (image == NULL) { - // reduce height - height2 = height >> 1; - nextrow = width << 2; - for (y = 0;y < height2;y++) - { - for (x = 0;x < width;x++) - { - 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; - } - in += nextrow; // skip a line - } + Con_Printf ("R_FindImageForTexture: ran out of memory\n"); + return; } - else - Sys_Error("GL_MipReduce: desired size already achieved\n"); + image->type = GLIMAGETYPE_TILE; + image->blockallocation = NULL; + + picmip = 0; + if (glt->flags & TEXF_PICMIP) + picmip = gl_picmip.integer; + // calculate final size + if (gl_max_size.integer > realmaxsize) + Cvar_SetValue("gl_max_size", realmaxsize); + for (image->width = 1;image->width < glt->width;image->width <<= 1); + for (image->height = 1;image->height < glt->height;image->height <<= 1); + for (image->depth = 1;image->depth < glt->depth;image->depth <<= 1); + for (image->width >>= picmip;image->width > gl_max_size.integer;image->width >>= 1); + for (image->height >>= picmip;image->height > gl_max_size.integer;image->height >>= 1); + for (image->depth >>= picmip;image->depth > gl_max_size.integer;image->depth >>= 1); + if (image->width < 1) image->width = 1; + if (image->height < 1) image->height = 1; + if (image->depth < 1) image->depth = 1; } + image->texturetype = glt->texturetype; + image->glinternalformat = texinfo->glinternalformat; + image->glformat = texinfo->glformat; + image->flags = (glt->flags & (TEXF_MIPMAP | TEXF_ALPHA | TEXF_CLAMP | TEXF_PICMIP | TEXF_FORCENEAREST | TEXF_FORCELINEAR)) | GLTEXF_UPLOAD; + image->bytesperpixel = texinfo->internalbytesperpixel; + image->sides = image->texturetype == GLTEXTURETYPE_CUBEMAP ? 6 : 1; + // get a texture number to use + qglGenTextures(1, (GLuint *)&image->texnum); + *imagechainpointer = image; + image->texturecount++; + + glt->x = x; + glt->y = y; + glt->z = z; + glt->image = image; } -void GL_UploadTexture (gltexture_t *glt) +// note: R_FindImageForTexture must be called before this +static void R_UploadTexture (gltexture_t *glt) { - int mip, width, height; - 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 + if (!(glt->flags & GLTEXF_UPLOAD)) + return; + + R_Upload(glt, glt->inputtexels); + 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 qbyte *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 (cls.state == ca_dedicated) + return NULL; + + if (flags & TEXF_FRAGMENT && texturetype != GLTEXTURETYPE_2D) + { + Con_Printf ("R_LoadTexture: only 2D fragment textures implemented\n"); + return NULL; + } + if (texturetype == GLTEXTURETYPE_CUBEMAP && !gl_texturecubemap) + { + Con_Printf ("R_LoadTexture: cubemap texture not supported by driver\n"); + return NULL; + } + if (texturetype == GLTEXTURETYPE_3D && !gl_texture3d) + { + Con_Printf ("R_LoadTexture: 3d texture not supported by driver\n"); + return NULL; + } - if (isDedicated) - return 1; + texinfo = R_GetTexTypeInfo(textype, flags); + size = width * height * depth * sides * texinfo->inputbytesperpixel; + if (size < 1) + { + Con_Printf ("R_LoadTexture: bogus texture size (%dx%dx%dx%dbppx%dsides = %d bytes)\n", width, height, depth, texinfo->inputbytesperpixel * 8, sides); + 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]) + // clear the alpha flag if the texture has no transparent pixels + switch(textype) { - for (i=0, glt=gltextures ; iidentifier)) + flags &= ~TEXF_ALPHA; + if (data) { - // LordHavoc: everyone hates cache mismatchs, so I fixed it - if (crc != glt->crc || width != glt->width || height != glt->height) + for (i = 0;i < size;i++) { - 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 (((qbyte *)&palette[data[i]])[3] < 255) + { + flags |= TEXF_ALPHA; + break; + } } - if ((gl_lerpimages.value != 0) != glt->lerped) - goto GL_LoadTexture_setup; // drop out with glt pointing to the texture to replace - return glt->texnum; } } + break; + case TEXTYPE_RGB: + if (flags & TEXF_ALPHA) + Host_Error("R_LoadTexture: RGB has no alpha, don't specify TEXF_ALPHA\n"); + break; + case TEXTYPE_RGBA: + if (flags & TEXF_ALPHA) + { + flags &= ~TEXF_ALPHA; + if (data) + { + for (i = 3;i < size;i += 4) + { + if (data[i] < 255) + { + flags |= TEXF_ALPHA; + break; + } + } + } + } + break; + case TEXTYPE_DSDT: + break; + default: + Host_Error("R_LoadTexture: unknown texture type\n"); } - // 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 = (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->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); + glt->depth = depth; + glt->flags = flags | GLTEXF_UPLOAD; + glt->textype = texinfo; + glt->texturetype = texturetype; + glt->inputdatasize = size; + glt->palette = palette; + + if (data) + { + glt->inputtexels = (qbyte *)Mem_Alloc(texturemempool, size); + if (glt->inputtexels == NULL) + Con_Printf ("R_LoadTexture: out of memory\n"); else - Image_CopyRGBAGamma(data, glt->texels[0], width*height); + memcpy(glt->inputtexels, data, size); } - else if (width == width2 && height == height2) // perfect match for top level, but needs to be reduced + else + glt->inputtexels = NULL; + + R_FindImageForTexture(glt); + R_PrecacheTexture(glt); + + return (rtexture_t *)glt; +} + +rtexture_t *R_LoadTexture1D(rtexturepool_t *rtexturepool, const char *identifier, int width, const qbyte *data, int textype, int flags, const unsigned int *palette) +{ + return R_SetupTexture(rtexturepool, identifier, width, 1, 1, 1, flags, textype, GLTEXTURETYPE_1D, data, palette); +} + +rtexture_t *R_LoadTexture2D(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, const qbyte *data, int textype, int flags, const unsigned int *palette) +{ + return R_SetupTexture(rtexturepool, identifier, width, height, 1, 1, flags, textype, GLTEXTURETYPE_2D, data, palette); +} + +rtexture_t *R_LoadTexture3D(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, int depth, const qbyte *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 qbyte *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)->width : 0; +} + +int R_TextureHeight(rtexture_t *rt) +{ + return rt ? ((gltexture_t *)rt)->height : 0; +} + +void R_FragmentLocation3D(rtexture_t *rt, int *x, int *y, int *z, float *fx1, float *fy1, float *fz1, float *fx2, float *fy2, float *fz2) +{ + gltexture_t *glt; + float iwidth, iheight, idepth; + if (cls.state == ca_dedicated) { - 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) + if (x) + *x = 0; + if (y) + *y = 0; + if (z) + *z = 0; + if (fx1 || fy1 || fx2 || fy2) { - 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); + if (fx1) + *fx1 = 0; + if (fy1) + *fy1 = 0; + if (fz1) + *fz1 = 0; + if (fx2) + *fx2 = 1; + if (fy2) + *fy2 = 1; + if (fz2) + *fz2 = 1; } - free(temptexels2); + return; } - else // scaling... + if (!rt) + Host_Error("R_FragmentLocation: no texture supplied\n"); + glt = (gltexture_t *)rt; + if (glt->flags & TEXF_FRAGMENT) { - 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 + if (x) + *x = glt->x; + if (y) + *y = glt->y; + if (fx1 || fy1 || fx2 || fy2) { - byte *temptexels2; - temptexels2 = malloc(width2*height2*4); // scaleup buffer - GL_ResampleTexture(temptexels, width, height, temptexels2, width2, height2); - 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); + iwidth = 1.0f / glt->image->width; + iheight = 1.0f / glt->image->height; + idepth = 1.0f / glt->image->depth; + if (fx1) + *fx1 = glt->x * iwidth; + if (fy1) + *fy1 = glt->y * iheight; + if (fz1) + *fz1 = glt->z * idepth; + if (fx2) + *fx2 = (glt->x + glt->width) * iwidth; + if (fy2) + *fy2 = (glt->y + glt->height) * iheight; + if (fz2) + *fz2 = (glt->z + glt->depth) * idepth; } - else // copy directly - GL_ResampleTexture(temptexels, width, height, glt->texels[0], width2, height2); - free(temptexels); } - if (alpha) + else { - byte *in = glt->texels[0] + 3; - for (i = 0;i < width*height;i++, in += 4) - if (*in < 255) - { - glt->alpha = true; - break; - } + if (x) + *x = 0; + if (y) + *y = 0; + if (z) + *z = 0; + if (fx1 || fy1 || fx2 || fy2) + { + if (fx1) + *fx1 = 0; + if (fy1) + *fy1 = 0; + if (fz1) + *fz1 = 0; + if (fx2) + *fx2 = 1; + if (fy2) + *fy2 = 1; + if (fz2) + *fz2 = 1; + } } - // 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); - -// if (bytesperpixel == 1) // 8bit -// GL_Upload8 (data, width, height, mipmap, alpha); -// else // 32bit -// GL_Upload32 (data, width, height, mipmap, true); - - return glt->texnum; } -/* -================ -GL_LoadPicTexture -================ -*/ -int GL_LoadPicTexture (qpic_t *pic) +void R_FragmentLocation(rtexture_t *rt, int *x, int *y, float *fx1, float *fy1, float *fx2, float *fy2) { - return GL_LoadTexture ("", pic->width, pic->height, pic->data, false, true, 1); + R_FragmentLocation3D(rt, x, y, NULL, fx1, fy1, NULL, fx2, fy2, NULL); } -int GL_GetTextureSlots (int count) +int R_CompatibleFragmentWidth(int width, int textype, int flags) { - gltexture_t *glt, *first; + return width; +} - 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; +void R_UpdateTexture(rtexture_t *rt, qbyte *data) +{ + gltexture_t *glt; + if (rt == NULL) + Host_Error("R_UpdateTexture: no texture supplied\n"); + if (data == NULL) + Host_Error("R_UpdateTexture: no data supplied\n"); + glt = (gltexture_t *)rt; + + // if it has not been uploaded yet, update the data that will be used when it is + if (glt->inputtexels) + memcpy(glt->inputtexels, data, glt->inputdatasize); + else + R_Upload(glt, data); } +