X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=gl_textures.c;h=e5d35a9ac4f264221550d8e6f9a48632c1fd57bc;hb=1f38eee898a31c94cd3b9931ea3af6e83d51c2c4;hp=6248f5bcf120980d17b40f7071ed870035132eaa;hpb=4d162c39ec059b7f3191fbb4fb18304bc9b1db59;p=xonotic%2Fdarkplaces.git diff --git a/gl_textures.c b/gl_textures.c index 6248f5bc..e5d35a9a 100644 --- a/gl_textures.c +++ b/gl_textures.c @@ -1,65 +1,368 @@ -#include "quakedef.h" -cvar_t r_max_size = {"r_max_size", "2048"}; -cvar_t r_picmip = {"r_picmip", "0"}; -cvar_t r_lerpimages = {"r_lerpimages", "1"}; -cvar_t r_upload = {"r_upload", "1"}; -cvar_t r_precachetextures = {"r_precachetextures", "1", true}; +#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"}; +cvar_t gl_texturecompression = {CVAR_SAVE, "gl_texturecompression", "0", "whether to compress textures, a value of 0 disables compression (even if the individual cvars are 1), 1 enables fast (low quality) compression at startup, 2 enables slow (high quality) compression at startup"}; +cvar_t gl_texturecompression_color = {CVAR_SAVE, "gl_texturecompression_color", "1", "whether to compress colormap (diffuse) textures"}; +cvar_t gl_texturecompression_normal = {CVAR_SAVE, "gl_texturecompression_normal", "0", "whether to compress normalmap (normalmap) textures"}; +cvar_t gl_texturecompression_gloss = {CVAR_SAVE, "gl_texturecompression_gloss", "1", "whether to compress glossmap (specular) textures"}; +cvar_t gl_texturecompression_glow = {CVAR_SAVE, "gl_texturecompression_glow", "1", "whether to compress glowmap (luma) textures"}; +cvar_t gl_texturecompression_2d = {CVAR_SAVE, "gl_texturecompression_2d", "0", "whether to compress 2d (hud/menu) textures other than the font"}; +cvar_t gl_texturecompression_q3bsplightmaps = {CVAR_SAVE, "gl_texturecompression_q3bsplightmaps", "0", "whether to compress lightmaps in q3bsp format levels"}; +cvar_t gl_texturecompression_q3bspdeluxemaps = {CVAR_SAVE, "gl_texturecompression_q3bspdeluxemaps", "0", "whether to compress deluxemaps in q3bsp format levels (only levels compiled with q3map2 -deluxe have these)"}; +cvar_t gl_texturecompression_sky = {CVAR_SAVE, "gl_texturecompression_sky", "0", "whether to compress sky textures"}; +cvar_t gl_texturecompression_lightcubemaps = {CVAR_SAVE, "gl_texturecompression_lightcubemaps", "1", "whether to compress light cubemaps (spotlights and other light projection images)"}; + +int gl_filter_min = GL_LINEAR_MIPMAP_LINEAR; +int gl_filter_mag = 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 +// dynamic texture (treat texnum == 0 differently) +#define GLTEXF_DYNAMIC 0x00080000 + +typedef struct textypeinfo_s +{ + textype_t textype; + int inputbytesperpixel; + int internalbytesperpixel; + float glinternalbytesperpixel; + int glformat; + int glinternalformat; +} +textypeinfo_t; + +static textypeinfo_t textype_palette = {TEXTYPE_PALETTE, 1, 4, 4.0f, GL_BGRA , 3}; +static textypeinfo_t textype_palette_alpha = {TEXTYPE_PALETTE, 1, 4, 4.0f, GL_BGRA , 4}; +static textypeinfo_t textype_palette_compress = {TEXTYPE_PALETTE, 1, 4, 0.5f, GL_BGRA , GL_COMPRESSED_RGB_ARB}; +static textypeinfo_t textype_palette_alpha_compress = {TEXTYPE_PALETTE, 1, 4, 1.0f, GL_BGRA , GL_COMPRESSED_RGBA_ARB}; +static textypeinfo_t textype_rgba = {TEXTYPE_RGBA , 4, 4, 4.0f, GL_RGBA , 3}; +static textypeinfo_t textype_rgba_alpha = {TEXTYPE_RGBA , 4, 4, 4.0f, GL_RGBA , 4}; +static textypeinfo_t textype_rgba_compress = {TEXTYPE_RGBA , 4, 4, 0.5f, GL_RGBA , GL_COMPRESSED_RGB_ARB}; +static textypeinfo_t textype_rgba_alpha_compress = {TEXTYPE_RGBA , 4, 4, 1.0f, GL_RGBA , GL_COMPRESSED_RGBA_ARB}; +static textypeinfo_t textype_bgra = {TEXTYPE_BGRA , 4, 4, 4.0f, GL_BGRA , 3}; +static textypeinfo_t textype_bgra_alpha = {TEXTYPE_BGRA , 4, 4, 4.0f, GL_BGRA , 4}; +static textypeinfo_t textype_bgra_compress = {TEXTYPE_BGRA , 4, 4, 0.5f, GL_BGRA , GL_COMPRESSED_RGB_ARB}; +static textypeinfo_t textype_bgra_alpha_compress = {TEXTYPE_BGRA , 4, 4, 1.0f, GL_BGRA , GL_COMPRESSED_RGBA_ARB}; + +#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 gl_filter_min = GL_LINEAR_MIPMAP_LINEAR; //NEAREST; -int gl_filter_max = GL_LINEAR; +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 + + // dynamic texture stuff [11/22/2007 Black] + // used to hold the texture number of dirty textures + int dirtytexnum; + updatecallback_t updatecallback; + void *updatacallback_data; + // --- [11/22/2007 Black] + + // 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[MAX_QPATH + 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; +#define TEXTUREPOOL_SENTINEL 0xC0DEDBAD -int texels; +typedef struct gltexturepool_s +{ + unsigned int sentinel; + struct gltexture_s *gltchain; + struct gltexturepool_s *next; +} +gltexturepool_t; -// 65536x65536 -#define MAXMIPS 16 +static gltexturepool_t *gltexturepoolchain = NULL; -#define GLTEXF_LERPED 1 -#define GLTEXF_UPLOADED 2 +static unsigned char *resizebuffer = NULL, *colorconvertbuffer; +static int resizebuffersize = 0; +static const unsigned char *texturebuffer; +static int texturebuffersize = 0; -typedef struct +static textypeinfo_t *R_GetTexTypeInfo(textype_t textype, int flags) { - char identifier[64]; - int texnum; // GL texture slot number - int texeldatasize; // computed memory usage of this texture (including mipmaps, expansion to 32bit, etc) - byte *inputtexels; // copy of the original texture supplied to the upload function, for re-uploading or deferred uploads (non-precached) - int inputtexeldatasize; // size of the original texture - unsigned short width, height; -// LordHavoc: CRC to identify cache mismatchs - unsigned short crc; - int flags; // the requested flags when the texture was supplied to the upload function - int internalflags; // internal notes (lerped, etc) -} gltexture_t; + if ((flags & TEXF_COMPRESS) && gl_texturecompression.integer >= 1 && gl_support_texture_compression) + { + if (flags & TEXF_ALPHA) + { + switch(textype) + { + case TEXTYPE_PALETTE: + return &textype_palette_alpha_compress; + case TEXTYPE_RGBA: + return &textype_rgba_alpha_compress; + case TEXTYPE_BGRA: + return &textype_bgra_alpha_compress; + default: + Host_Error("R_GetTexTypeInfo: unknown texture format"); + return NULL; + } + } + else + { + switch(textype) + { + case TEXTYPE_PALETTE: + return &textype_palette_compress; + case TEXTYPE_RGBA: + return &textype_rgba_compress; + case TEXTYPE_BGRA: + return &textype_bgra_compress; + default: + Host_Error("R_GetTexTypeInfo: unknown texture format"); + return NULL; + } + } + } + else + { + if (flags & TEXF_ALPHA) + { + switch(textype) + { + case TEXTYPE_PALETTE: + return &textype_palette_alpha; + case TEXTYPE_RGBA: + return &textype_rgba_alpha; + case TEXTYPE_BGRA: + return &textype_bgra_alpha; + default: + Host_Error("R_GetTexTypeInfo: unknown texture format"); + return NULL; + } + } + else + { + switch(textype) + { + case TEXTYPE_PALETTE: + return &textype_palette; + case TEXTYPE_RGBA: + return &textype_rgba; + case TEXTYPE_BGRA: + return &textype_bgra; + default: + Host_Error("R_GetTexTypeInfo: unknown texture format"); + return NULL; + } + } + } + return NULL; // this line only to hush compiler warnings +} + +// dynamic texture code [11/22/2007 Black] +void R_MarkDirtyTexture(rtexture_t *rt) { + gltexture_t *glt = (gltexture_t*) rt; + if( !glt ) { + return; + } + + // dont do anything if the texture is already dirty (and make sure this *is* a dynamic texture after all!) + if( !glt->dirtytexnum && glt->flags & GLTEXF_DYNAMIC ) { + glt->dirtytexnum = glt->texnum; + // mark it as dirty, so R_RealGetTexture gets called + glt->texnum = 0; + } +} + +void R_MakeTextureDynamic(rtexture_t *rt, updatecallback_t updatecallback, void *data) { + gltexture_t *glt = (gltexture_t*) rt; + if( !glt ) { + return; + } -#define MAX_GLTEXTURES 4096 -gltexture_t *gltextures; -unsigned int numgltextures = 0, gl_texture_number = 1; + glt->flags |= GLTEXF_DYNAMIC; + glt->updatecallback = updatecallback; + glt->updatacallback_data = data; + glt->dirtytexnum = 0; +} + +static void R_UpdateDynamicTexture(gltexture_t *glt) { + glt->texnum = glt->dirtytexnum; + // reset dirtytexnum again (not dirty anymore) + glt->dirtytexnum = 0; + // TODO: now assert that t->texnum != 0 ? + if( glt->updatecallback ) { + glt->updatecallback( (rtexture_t*) glt, glt->updatacallback_data ); + } +} -void GL_UploadTexture(gltexture_t *t); +static void R_UploadTexture(gltexture_t *t); -int R_GetTexture(rtexture_t *rt) +static void R_PrecacheTexture(gltexture_t *glt) { - gltexture_t *glt; - if (!rt) + 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_DYNAMIC) + R_UpdateDynamicTexture(glt); + if (glt->flags & GLTEXF_UPLOAD) + R_UploadTexture(glt); + + return glt->texnum; + } + else return 0; +} + +void R_PurgeTexture(rtexture_t *rt) +{ + if(rt && !(((gltexture_t*) rt)->flags & TEXF_PERSISTENT)) { + R_FreeTexture(rt); + } +} + +void R_FreeTexture(rtexture_t *rt) +{ + gltexture_t *glt, **gltpointer; + glt = (gltexture_t *)rt; - if (!(glt->internalflags & GLTEXF_UPLOADED)) + 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->flags & GLTEXF_UPLOAD)) { - GL_UploadTexture(glt); - if (!(glt->internalflags & GLTEXF_UPLOADED)) - Host_Error("R_GetTexture: unable to upload texture\n"); + CHECKGLERROR + qglDeleteTextures(1, (GLuint *)&glt->texnum);CHECKGLERROR } - return glt->texnum; + + 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; } -typedef struct +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}, @@ -69,619 +372,756 @@ 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->flags & TEXF_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 + } } } } -void GL_TextureStats_Print(char *name, int total, int total2, int loaded, int crc, int mip, int alpha, int total2valid) +static void GL_Texture_CalcImageSize(int texturetype, int flags, int inwidth, int inheight, int indepth, int *outwidth, int *outheight, int *outdepth) { - if (!name[0]) - name = ""; - Con_Printf("%5iK %c%5iK%c %04X %s %s %s %s\n", total, total2valid ? ' ' : '(', total2, total2valid ? ' ' : ')', crc, loaded ? "loaded" : " ", mip ? "mip" : " ", alpha ? "alpha" : " ", name); + int picmip = 0, maxsize = 0, width2 = 1, height2 = 1, depth2 = 1; + + if (gl_max_size.integer > gl_max_texture_size) + Cvar_SetValue("gl_max_size", gl_max_texture_size); + + switch (texturetype) + { + 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; + } + + if (flags & TEXF_PICMIP) + { + maxsize = min(maxsize, gl_max_size.integer); + picmip = gl_picmip.integer; + } + + if (outwidth) + { + if (gl_support_arb_texture_non_power_of_two) + width2 = min(inwidth >> picmip, maxsize); + else + { + for (width2 = 1;width2 < inwidth;width2 <<= 1); + for (width2 >>= picmip;width2 > maxsize;width2 >>= 1); + } + *outwidth = max(1, width2); + } + if (outheight) + { + if (gl_support_arb_texture_non_power_of_two) + height2 = min(inheight >> picmip, maxsize); + else + { + for (height2 = 1;height2 < inheight;height2 <<= 1); + for (height2 >>= picmip;height2 > maxsize;height2 >>= 1); + } + *outheight = max(1, height2); + } + if (outdepth) + { + if (gl_support_arb_texture_non_power_of_two) + depth2 = min(indepth >> picmip, maxsize); + else + { + for (depth2 = 1;depth2 < indepth;depth2 <<= 1); + for (depth2 >>= picmip;depth2 > maxsize;depth2 >>= 1); + } + *outdepth = max(1, depth2); + } } -void GL_TextureStats_PrintTotal(void) + +static int R_CalcTexelDataSize (gltexture_t *glt) { - int i, t = 0, p = 0, loaded = 0, loadedt = 0, loadedp = 0; - gltexture_t *glt; - for (i = 0, glt = gltextures;i < numgltextures;i++, glt++) + int width2, height2, depth2, size; + + 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) { - t += glt->texeldatasize; - p += glt->inputtexeldatasize; - if (glt->internalflags & GLTEXF_UPLOADED) + while (width2 > 1 || height2 > 1 || depth2 > 1) { - loaded++; - loadedt += glt->texeldatasize; - loadedp += glt->inputtexeldatasize; + if (width2 > 1) + width2 >>= 1; + if (height2 > 1) + height2 >>= 1; + if (depth2 > 1) + depth2 >>= 1; + size += width2 * height2 * depth2; } } - Con_Printf("total: %i (%.3fMB, %.3fMB original), uploaded %i (%.3fMB, %.3fMB original), upload on demand %i (%.3fMB, %.3fMB original)\n", numgltextures, t / 1048576.0, p / 1048576.0, loaded, loadedt / 1048576.0, loadedp / 1048576.0, numgltextures - loaded, (t - loadedt) / 1048576.0, (p - loadedp) / 1048576.0); + + return (int)(size * glt->textype->glinternalbytesperpixel) * glt->sides; } -void GL_TextureStats_f(void) +void R_TextureStats_Print(qboolean printeach, qboolean printpool, qboolean printtotal) { - int i; + 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; - Con_Printf("kbytes original crc loaded mip alpha name\n"); - for (i = 0, glt = gltextures;i < numgltextures;i++, glt++) - GL_TextureStats_Print(glt->identifier, (glt->texeldatasize + 1023) / 1024, (glt->inputtexeldatasize + 1023) / 1024, glt->internalflags & GLTEXF_UPLOADED, glt->crc, glt->flags & TEXF_MIPMAP, glt->flags & TEXF_ALPHA, glt->inputtexels != NULL); - GL_TextureStats_PrintTotal(); + 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) + { + 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); } -char engineversion[40]; +static void R_TextureStats_f(void) +{ + R_TextureStats_Print(true, true, true); +} -//void GL_UploadTexture (gltexture_t *glt); -void r_textures_start() +static void r_textures_start(void) { -// int i; -// gltexture_t *glt; -// for (i=0, glt=gltextures ; iidentifier)) - return gltextures[i].texnum; + Mem_Free(resizebuffer); + resizebuffer = NULL; } - - return -1; -} - -void R_ResampleTextureLerpLine (byte *in, byte *out, int inwidth, int outwidth) -{ - int j, xi, oldx = 0, f, fstep, endx; - fstep = (int) (inwidth*65536.0f/outwidth); - endx = (inwidth-1); - for (j = 0,f = 0;j < outwidth;j++, f += fstep) + if (colorconvertbuffer) { - xi = (int) f >> 16; - if (xi != oldx) - { - in += (xi - oldx) * 4; - oldx = xi; - } - if (xi < endx) - { - int lerp = f & 0xFFFF; - *out++ = (byte) ((((in[4] - in[0]) * lerp) >> 16) + in[0]); - *out++ = (byte) ((((in[5] - in[1]) * lerp) >> 16) + in[1]); - *out++ = (byte) ((((in[6] - in[2]) * lerp) >> 16) + in[2]); - *out++ = (byte) ((((in[7] - in[3]) * lerp) >> 16) + in[3]); - } - else // last pixel of the line has no pixel to lerp to - { - *out++ = in[0]; - *out++ = in[1]; - *out++ = in[2]; - *out++ = in[3]; - } + Mem_Free(colorconvertbuffer); + colorconvertbuffer = NULL; } -} - -/* -================ -R_ResampleTexture -================ -*/ -void R_ResampleTexture (void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight) -{ - if (outwidth & 3) - Sys_Error("R_ResampleTexture: output width must be a multiple of 4"); - if (r_lerpimages.value) + if (old_aniso != gl_texture_anisotropy.integer) { - int i, j, yi, oldy, f, fstep, endy = (inheight-1); - byte *inrow, *out, *row1, *row2; - out = outdata; - fstep = (int) (inheight*65536.0f/outheight); + gltexture_t *glt; + gltexturepool_t *pool; + GLint oldbindtexnum; + + old_aniso = bound(1, gl_texture_anisotropy.integer, gl_max_anisotropy); + + Cvar_SetValueQuick(&gl_texture_anisotropy, old_aniso); - row1 = qmalloc(outwidth*4); - row2 = qmalloc(outwidth*4); - inrow = indata; - oldy = 0; - R_ResampleTextureLerpLine (inrow, row1, inwidth, outwidth); - R_ResampleTextureLerpLine (inrow + inwidth*4, row2, inwidth, outwidth); - for (i = 0, f = 0;i < outheight;i++,f += fstep) + CHECKGLERROR + for (pool = gltexturepoolchain;pool;pool = pool->next) { - yi = f >> 16; - if (yi < endy) + for (glt = pool->gltchain;glt;glt = glt->chain) { - int lerp = f & 0xFFFF; - if (yi != oldy) + // only update already uploaded images + if ((glt->flags & (GLTEXF_UPLOAD | TEXF_MIPMAP)) == TEXF_MIPMAP) { - inrow = (byte *)indata + inwidth*4*yi; - if (yi == oldy+1) - memcpy(row1, row2, outwidth*4); - else - R_ResampleTextureLerpLine (inrow, row1, inwidth, outwidth); - R_ResampleTextureLerpLine (inrow + inwidth*4, row2, inwidth, outwidth); - oldy = yi; - } - for (j = 0;j < outwidth;j += 4) - { - out[ 0] = (byte) ((((row2[ 0] - row1[ 0]) * lerp) >> 16) + row1[ 0]); - out[ 1] = (byte) ((((row2[ 1] - row1[ 1]) * lerp) >> 16) + row1[ 1]); - out[ 2] = (byte) ((((row2[ 2] - row1[ 2]) * lerp) >> 16) + row1[ 2]); - out[ 3] = (byte) ((((row2[ 3] - row1[ 3]) * lerp) >> 16) + row1[ 3]); - out[ 4] = (byte) ((((row2[ 4] - row1[ 4]) * lerp) >> 16) + row1[ 4]); - out[ 5] = (byte) ((((row2[ 5] - row1[ 5]) * lerp) >> 16) + row1[ 5]); - out[ 6] = (byte) ((((row2[ 6] - row1[ 6]) * lerp) >> 16) + row1[ 6]); - out[ 7] = (byte) ((((row2[ 7] - row1[ 7]) * lerp) >> 16) + row1[ 7]); - out[ 8] = (byte) ((((row2[ 8] - row1[ 8]) * lerp) >> 16) + row1[ 8]); - out[ 9] = (byte) ((((row2[ 9] - row1[ 9]) * lerp) >> 16) + row1[ 9]); - out[10] = (byte) ((((row2[10] - row1[10]) * lerp) >> 16) + row1[10]); - out[11] = (byte) ((((row2[11] - row1[11]) * lerp) >> 16) + row1[11]); - out[12] = (byte) ((((row2[12] - row1[12]) * lerp) >> 16) + row1[12]); - out[13] = (byte) ((((row2[13] - row1[13]) * lerp) >> 16) + row1[13]); - out[14] = (byte) ((((row2[14] - row1[14]) * lerp) >> 16) + row1[14]); - out[15] = (byte) ((((row2[15] - row1[15]) * lerp) >> 16) + row1[15]); - out += 16; - row1 += 16; - row2 += 16; - } - row1 -= outwidth*4; - row2 -= outwidth*4; - } - else - { - if (yi != oldy) - { - inrow = (byte *)indata + inwidth*4*yi; - if (yi == oldy+1) - memcpy(row1, row2, outwidth*4); - else - R_ResampleTextureLerpLine (inrow, row1, inwidth, outwidth); - oldy = yi; + qglGetIntegerv(gltexturetypebindingenums[glt->texturetype], &oldbindtexnum);CHECKGLERROR + + qglBindTexture(gltexturetypeenums[glt->texturetype], glt->texnum);CHECKGLERROR + qglTexParameteri(gltexturetypeenums[glt->texturetype], GL_TEXTURE_MAX_ANISOTROPY_EXT, old_aniso);CHECKGLERROR + + qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR } - memcpy(out, row1, outwidth * 4); } } - qfree(row1); - qfree(row2); } - else - { - int i, j; - unsigned frac, fracstep; - // relies on int being 4 bytes - int *inrow, *out; - out = outdata; +} - fracstep = inwidth*0x10000/outwidth; - for (i = 0;i < outheight;i++) - { - inrow = (int *)indata + inwidth*(i*inheight/outheight); - frac = fracstep >> 1; - for (j = 0;j < outwidth;j += 4) - { - out[0] = inrow[frac >> 16];frac += fracstep; - out[1] = inrow[frac >> 16];frac += fracstep; - out[2] = inrow[frac >> 16];frac += fracstep; - out[3] = inrow[frac >> 16];frac += fracstep; - out += 4; - } - } +void R_MakeResizeBufferBigger(int size) +{ + 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"); } } -// in can be the same as out -void GL_MipReduce(byte *in, byte *out, int width, int height, int destwidth, int destheight) +static void GL_SetupTextureParameters(int flags, int texturetype) { - int x, y, width2, height2, nextrow; - if (width > destwidth) + int textureenum = gltexturetypeenums[texturetype]; + int wrapmode = ((flags & TEXF_CLAMP) && gl_support_clamptoedge) ? GL_CLAMP_TO_EDGE : GL_REPEAT; + + CHECKGLERROR + + if (gl_support_anisotropy && (flags & TEXF_MIPMAP)) + { + 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 + } + qglTexParameteri(textureenum, GL_TEXTURE_WRAP_S, wrapmode);CHECKGLERROR + qglTexParameteri(textureenum, GL_TEXTURE_WRAP_T, wrapmode);CHECKGLERROR + if (gltexturetypedimensions[texturetype] >= 3) + { + qglTexParameteri(textureenum, GL_TEXTURE_WRAP_R, wrapmode);CHECKGLERROR + } + + CHECKGLERROR + if (flags & TEXF_FORCENEAREST) { - if (height > destheight) + if (flags & TEXF_MIPMAP) { - // reduce both - width2 = width >> 1; - height2 = height >> 1; - nextrow = width << 2; - for (y = 0;y < height2;y++) - { - for (x = 0;x < width2;x++) - { - 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; - } - in += nextrow; // skip a line - } + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);CHECKGLERROR } else { - // reduce width - width2 = width >> 1; - for (y = 0;y < height;y++) + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_NEAREST);CHECKGLERROR + } + qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, GL_NEAREST);CHECKGLERROR + } + else if (flags & TEXF_FORCELINEAR) + { + if (flags & TEXF_MIPMAP) + { + if (gl_filter_min == GL_NEAREST_MIPMAP_LINEAR || gl_filter_min == GL_LINEAR_MIPMAP_LINEAR) { - for (x = 0;x < width2;x++) - { - 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; - } + 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 { - if (height > destheight) + if (flags & TEXF_MIPMAP) { - // 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 - } + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, gl_filter_min);CHECKGLERROR } else - Sys_Error("GL_MipReduce: desired size already achieved\n"); + { + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, gl_filter_mag);CHECKGLERROR + } + qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, gl_filter_mag);CHECKGLERROR } + + CHECKGLERROR } -void GL_Upload32(int glslot, byte *data, int width, int height, int flags) +static void R_Upload(gltexture_t *glt, const unsigned char *data, int fragx, int fragy, int fragz, int fragwidth, int fragheight, int fragdepth) { - int mip, width2, height2, width3, height3, internalformat; - byte *gammadata, *buffer; + int i, mip, width, height, depth; + GLint oldbindtexnum; + const unsigned char *prevbuffer; + prevbuffer = data; - if (!r_upload.value) - return; - - // 3 and 4 are converted by the driver to it's preferred format for the current display mode - internalformat = 3; - if (flags & TEXF_ALPHA) - internalformat = 4; - - // 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) r_picmip.value; - height3 = height2 >> (int) r_picmip.value; - while (width3 > (int) r_max_size.value) width3 >>= 1; - while (height3 > (int) r_max_size.value) height3 >>= 1; - if (width3 < 1) width3 = 1; - if (height3 < 1) height3 = 1; + CHECKGLERROR - gammadata = qmalloc(width*height*4); - buffer = qmalloc(width2*height2*4); - if (!gammadata || !buffer) - Host_Error("GL_Upload32: out of memory\n"); + // we need to restore the texture binding after finishing the upload + qglGetIntegerv(gltexturetypebindingenums[glt->texturetype], &oldbindtexnum);CHECKGLERROR + qglBindTexture(gltexturetypeenums[glt->texturetype], glt->texnum);CHECKGLERROR - Image_CopyRGBAGamma(data, gammadata, width*height); - - R_ResampleTexture(gammadata, width, height, buffer, width2, height2); + // these are rounded up versions of the size to do better resampling + if (gl_support_arb_texture_non_power_of_two) + { + width = glt->inputwidth; + height = glt->inputheight; + depth = glt->inputdepth; + } + else + { + for (width = 1;width < glt->inputwidth ;width <<= 1); + for (height = 1;height < glt->inputheight;height <<= 1); + for (depth = 1;depth < glt->inputdepth ;depth <<= 1); + } - qfree(gammadata); + R_MakeResizeBufferBigger(width * height * depth * glt->sides * glt->bytesperpixel); + R_MakeResizeBufferBigger(fragwidth * fragheight * fragdepth * glt->sides * glt->bytesperpixel); - while (width2 > width3 || height2 > height3) + if (prevbuffer == NULL) { - GL_MipReduce(buffer, buffer, width2, height2, width3, height3); - - if (width2 > width3) - width2 >>= 1; - if (height2 > height3) - height2 >>= 1; + memset(resizebuffer, 0, fragwidth * fragheight * fragdepth * glt->bytesperpixel); + prevbuffer = resizebuffer; + } + else if (glt->textype->textype == TEXTYPE_PALETTE) + { + // promote paletted to BGRA, so we only have to worry about BGRA in the rest of this code + Image_Copy8bitBGRA(prevbuffer, colorconvertbuffer, fragwidth * fragheight * fragdepth * glt->sides, glt->palette); + prevbuffer = colorconvertbuffer; } - glBindTexture(GL_TEXTURE_2D, glslot); - mip = 0; - glTexImage2D(GL_TEXTURE_2D, mip++, internalformat, width2, height2, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer); - if (flags & TEXF_MIPMAP) + if ((glt->flags & (TEXF_MIPMAP | TEXF_PICMIP | GLTEXF_UPLOAD)) == 0 && glt->inputwidth == glt->tilewidth && glt->inputheight == glt->tileheight && glt->inputdepth == glt->tiledepth) { - while (width2 > 1 || height2 > 1) + // update a portion of the image + switch(glt->texturetype) { - GL_MipReduce(buffer, buffer, width2, height2, 1, 1); - - if (width2 > 1) - width2 >>= 1; - if (height2 > 1) - height2 >>= 1; - - glTexImage2D(GL_TEXTURE_2D, mip++, internalformat, width2, height2, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer); + 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; } - - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); } else { - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); - } - glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + 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"); - qfree(buffer); -} + // upload the image for the first time + glt->flags &= ~GLTEXF_UPLOAD; -void GL_Upload8 (int glslot, byte *data, int width, int height, int flags) -{ - byte *data32; - data32 = qmalloc(width*height*4); - Image_Copy8bitRGBA(data, data32, width*height, d_8to24table); - GL_Upload32(glslot, data32, width, height, flags); - qfree(data32); -} - -void GL_UploadTexture (gltexture_t *glt) -{ - if (glt->inputtexels == NULL) - return; - if (glt->flags & TEXF_RGBA) - GL_Upload32(glt->texnum, glt->inputtexels, glt->width, glt->height, glt->flags); - else // 8bit - GL_Upload8(glt->texnum, glt->inputtexels, glt->width, glt->height, glt->flags); - glt->internalflags |= GLTEXF_UPLOADED; - qfree(glt->inputtexels); - glt->inputtexels = NULL; -} - -int R_CalcTexelDataSize (int width, int height, int mipmapped) -{ - int width2, height2, size; - width2 = 1;while (width2 < width) width2 <<= 1; - height2 = 1;while (height2 < height) height2 <<= 1; - // calculate final size (mipmapped downward to this) - width2 >>= (int) r_picmip.value; - height2 >>= (int) r_picmip.value; - while (width2 > (int) r_max_size.value) width2 >>= 1; - while (height2 > (int) r_max_size.value) height2 >>= 1; - if (width2 < 1) width2 = 1; - if (height2 < 1) height2 = 1; - - size = 0; - if (mipmapped) - { - while (width2 > 1 || height2 > 1) + // cubemaps contain multiple images and thus get processed a bit differently + if (glt->texturetype != GLTEXTURETYPE_CUBEMAP) { - size += width2 * height2; - if (width2 > 1) - width2 >>= 1; - if (height2 > 1) - height2 >>= 1; + if (glt->inputwidth != width || glt->inputheight != height || glt->inputdepth != depth) + { + Image_Resample32(prevbuffer, glt->inputwidth, glt->inputheight, glt->inputdepth, resizebuffer, width, height, depth, r_lerpimages.integer); + prevbuffer = resizebuffer; + } + // picmip/max_size + while (width > glt->tilewidth || height > glt->tileheight || depth > glt->tiledepth) + { + Image_MipReduce32(prevbuffer, resizebuffer, &width, &height, &depth, glt->tilewidth, glt->tileheight, glt->tiledepth); + prevbuffer = resizebuffer; + } } - size++; // count the last 1x1 mipmap + mip = 0; + if (gl_support_texture_compression) + { + if (gl_texturecompression.integer >= 2) + qglHint(GL_TEXTURE_COMPRESSION_HINT_ARB, GL_NICEST); + else + qglHint(GL_TEXTURE_COMPRESSION_HINT_ARB, GL_FASTEST); + CHECKGLERROR + } + switch(glt->texturetype) + { + case GLTEXTURETYPE_1D: + qglTexImage1D(GL_TEXTURE_1D, mip++, glt->glinternalformat, width, 0, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR + if (glt->flags & TEXF_MIPMAP) + { + while (width > 1 || height > 1 || depth > 1) + { + Image_MipReduce32(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1); + prevbuffer = resizebuffer; + qglTexImage1D(GL_TEXTURE_1D, mip++, glt->glinternalformat, width, 0, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR + } + } + 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) + { + while (width > 1 || height > 1 || depth > 1) + { + Image_MipReduce32(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1); + prevbuffer = resizebuffer; + qglTexImage2D(GL_TEXTURE_2D, mip++, glt->glinternalformat, width, height, 0, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR + } + } + 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_MipReduce32(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1); + 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 = (unsigned char *)prevbuffer; + for (i = 0;i < 6;i++) + { + prevbuffer = texturebuffer; + texturebuffer += glt->inputwidth * glt->inputheight * glt->inputdepth * glt->textype->inputbytesperpixel; + if (glt->inputwidth != width || glt->inputheight != height || glt->inputdepth != depth) + { + Image_Resample32(prevbuffer, glt->inputwidth, glt->inputheight, glt->inputdepth, resizebuffer, width, height, depth, r_lerpimages.integer); + prevbuffer = resizebuffer; + } + // picmip/max_size + while (width > glt->tilewidth || height > glt->tileheight || depth > glt->tiledepth) + { + Image_MipReduce32(prevbuffer, resizebuffer, &width, &height, &depth, glt->tilewidth, glt->tileheight, glt->tiledepth); + 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_MipReduce32(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1); + prevbuffer = resizebuffer; + qglTexImage2D(cubemapside[i], mip++, glt->glinternalformat, width, height, 0, glt->glformat, GL_UNSIGNED_BYTE, prevbuffer);CHECKGLERROR + } + } + } + break; + } + GL_SetupTextureParameters(glt->flags, glt->texturetype); } - else - size = width2*height2; + qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR +} - size *= 4; // RGBA +static void R_UploadTexture (gltexture_t *glt) +{ + if (!(glt->flags & GLTEXF_UPLOAD)) + return; - return size; + CHECKGLERROR + qglGenTextures(1, (GLuint *)&glt->texnum);CHECKGLERROR + R_Upload(glt, glt->inputtexels, 0, 0, 0, glt->inputwidth, glt->inputheight, glt->inputdepth); + if (glt->inputtexels) + { + Mem_Free(glt->inputtexels); + glt->inputtexels = NULL; + glt->flags |= GLTEXF_DESTROYED; + } + 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 -================ -*/ -rtexture_t *R_LoadTexture (char *identifier, int width, int height, byte *data, int flags) +static rtexture_t *R_SetupTexture(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, int depth, int sides, int flags, textype_t textype, int texturetype, const unsigned char *data, const unsigned int *palette) { - int i, bytesperpixel, internalflags, precache; - gltexture_t *glt; - unsigned short crc; + int i, size; + gltexture_t *glt; + gltexturepool_t *pool = (gltexturepool_t *)rtexturepool; + textypeinfo_t *texinfo; - if (isDedicated) + if (cls.state == ca_dedicated) return NULL; - if (!identifier[0]) - Host_Error("R_LoadTexture: no identifier\n"); + 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; + } + + 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, size); + return NULL; + } // clear the alpha flag if the texture has no transparent pixels - if (flags & TEXF_ALPHA) + switch(textype) { - int alpha = false; - if (flags & TEXF_RGBA) + case TEXTYPE_PALETTE: + if (flags & TEXF_ALPHA) { - for (i = 0;i < width * height;i++) + flags &= ~TEXF_ALPHA; + if (data) { - if (data[i * 4 + 3] < 255) + for (i = 0;i < size;i++) { - alpha = true; - break; + if (((unsigned char *)&palette[data[i]])[3] < 255) + { + flags |= TEXF_ALPHA; + break; + } } } } - else + break; + case TEXTYPE_RGBA: + case TEXTYPE_BGRA: + if (flags & TEXF_ALPHA) { - for (i = 0;i < width * height;i++) + flags &= ~TEXF_ALPHA; + if (data) { - if (data[i] == 255) + for (i = 3;i < size;i += 4) { - alpha = true; - break; + if (data[i] < 255) + { + flags |= TEXF_ALPHA; + break; + } } } } - if (!alpha) - flags &= ~TEXF_ALPHA; + break; + default: + Host_Error("R_LoadTexture: unknown texture type"); } - if (flags & TEXF_RGBA) - bytesperpixel = 4; + 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 = 0; + // init the dynamic texture attributes, too [11/22/2007 Black] + glt->dirtytexnum = 0; + glt->updatecallback = NULL; + glt->updatacallback_data = NULL; + + if (data) + { + glt->inputtexels = (unsigned char *)Mem_Alloc(texturemempool, size); + memcpy(glt->inputtexels, data, size); + } else - bytesperpixel = 1; + glt->inputtexels = NULL; - internalflags = 0; - if (r_lerpimages.value != 0) - internalflags |= GLTEXF_LERPED; + GL_Texture_CalcImageSize(glt->texturetype, glt->flags, glt->inputwidth, glt->inputheight, glt->inputdepth, &glt->tilewidth, &glt->tileheight, &glt->tiledepth); + R_PrecacheTexture(glt); - // 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 - 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 || flags != glt->flags) - { - Con_DPrintf("GL_LoadTexture: cache mismatch, replacing old texture\n"); - goto GL_LoadTexture_setup; // drop out with glt pointing to the texture to replace - } - if (internalflags != glt->internalflags) - goto GL_LoadTexture_setup; // drop out with glt pointing to the texture to replace - return (rtexture_t *)glt; - } - } + return (rtexture_t *)glt; +} -/* - if (freeglt) - { - glt = freeglt; - strcpy (glt->identifier, identifier); - } - else - { -*/ - // 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++]; - glt->texnum = gl_texture_number++; - strcpy (glt->identifier, identifier); -// } - -// LordHavoc: label to drop out of the loop into the setup code -GL_LoadTexture_setup: - glt->crc = crc; // LordHavoc: used to verify textures are identical - glt->width = width; - glt->height = height; - glt->flags = flags; - glt->internalflags = internalflags; +rtexture_t *R_LoadTexture1D(rtexturepool_t *rtexturepool, const char *identifier, int width, const unsigned char *data, textype_t textype, int flags, const unsigned int *palette) +{ + return R_SetupTexture(rtexturepool, identifier, width, 1, 1, 1, flags, textype, GLTEXTURETYPE_1D, data, palette); +} - if (glt->inputtexels) - qfree(glt->inputtexels); - glt->inputtexeldatasize = width*height*bytesperpixel; - glt->inputtexels = qmalloc(glt->inputtexeldatasize); +rtexture_t *R_LoadTexture2D(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, const unsigned char *data, textype_t textype, int flags, const unsigned int *palette) +{ + 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 unsigned char *data, textype_t 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, textype_t textype, int flags, const unsigned int *palette) +{ + return R_SetupTexture(rtexturepool, identifier, width, width, 1, 6, flags, textype, GLTEXTURETYPE_CUBEMAP, data, palette); +} - memcpy(glt->inputtexels, data, glt->inputtexeldatasize); +int R_TextureHasAlpha(rtexture_t *rt) +{ + return rt ? (((gltexture_t *)rt)->flags & TEXF_ALPHA) != 0 : false; +} - glt->texeldatasize = R_CalcTexelDataSize(width, height, flags & TEXF_MIPMAP); +int R_TextureWidth(rtexture_t *rt) +{ + return rt ? ((gltexture_t *)rt)->inputwidth : 0; +} - precache = false; - if (r_precachetextures.value >= 1) - { - if (flags & TEXF_PRECACHE) - precache = true; - if (r_precachetextures.value >= 2) - precache = true; - } +int R_TextureHeight(rtexture_t *rt) +{ + return rt ? ((gltexture_t *)rt)->inputheight : 0; +} - if (precache) - GL_UploadTexture(glt); +void R_UpdateTexture(rtexture_t *rt, const 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; - return (rtexture_t *)glt; + // 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); } -// only used for lightmaps -int R_GetTextureSlots(int count) +void R_ClearTexture (rtexture_t *rt) { - int i; - i = gl_texture_number; - gl_texture_number += count; - return i; + gltexture_t *glt = (gltexture_t *)rt; + + R_Upload( glt, NULL, 0, 0, 0, glt->tilewidth, glt->tileheight, glt->tiledepth ); }