X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=gl_textures.c;h=cc43c8d37085be3dff3d14bf0f38d30b604f10dc;hp=3cc49e4d4db659d183387cb680166029f5b408b2;hb=8cebaa695fbe11bc631e3e5fd070e22f151f4710;hpb=b189c179b5f8f8a57582fa53de008eee7df83954 diff --git a/gl_textures.c b/gl_textures.c index 3cc49e4d..cc43c8d3 100644 --- a/gl_textures.c +++ b/gl_textures.c @@ -1,65 +1,321 @@ + #include "quakedef.h" +#include "image.h" +#include "jpeg.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}; +cvar_t r_max_size = {CVAR_SAVE, "r_max_size", "2048"}; +cvar_t r_max_scrapsize = {CVAR_SAVE, "r_max_scrapsize", "256"}; +cvar_t r_picmip = {CVAR_SAVE, "r_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", "0"}; -int gl_filter_min = GL_LINEAR_MIPMAP_LINEAR; //NEAREST; -int gl_filter_max = GL_LINEAR; +int gl_filter_min = GL_LINEAR_MIPMAP_LINEAR; +int gl_filter_mag = GL_LINEAR; -int texels; +static mempool_t *texturemempool; +static mempool_t *texturedatamempool; +static mempool_t *textureprocessingmempool; -// 65536x65536 -#define MAXMIPS 16 +// 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 -#define GLTEXF_LERPED 1 -#define GLTEXF_UPLOADED 2 +// size of images which hold fragment textures, ignores picmip and max_size +static int block_size; typedef struct { - 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; + 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] = +{ + 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; -unsigned int numgltextures = 0, gl_texture_number = 1; +// 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; -void GL_UploadTexture(gltexture_t *t); +typedef struct gltexture_s +{ + // this field is exposed to the R_GetTexture macro, for speed reasons + // (must be identical in rtexture_t) + int texnum; // GL texture slot number + + // pointer to texturepool (check this to see if the texture is allocated) + struct gltexturepool_s *pool; + // pointer to next texture in texturepool chain + struct gltexture_s *chain; + // pointer into gltextureimage array + gltextureimage_t *image; + // name of the texture (this might be removed someday), no duplicates + char *identifier; + // 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; + +#define TEXTUREPOOL_SENTINEL 0xC0DEDBAD -int R_GetTexture(rtexture_t *rt) +typedef struct gltexturepool_s { - gltexture_t *glt; - if (!rt) + unsigned int sentinel; + struct gltextureimage_s *imagechain; + struct gltexture_s *gltchain; + struct gltexturepool_s *next; +} +gltexturepool_t; + +static gltexturepool_t *gltexturepoolchain = NULL; + +static qbyte *resizebuffer = NULL, *colorconvertbuffer; +static int resizebuffersize = 0; +static qbyte *texturebuffer; +static int texturebuffersize = 0; + +static int realmaxsize = 0; + +static textypeinfo_t *R_GetTexTypeInfo(int textype, int flags) +{ + if (flags & TEXF_ALPHA) + { + switch(textype) + { + case TEXTYPE_PALETTE: + return &textype_palette_alpha; + case TEXTYPE_RGB: + Host_Error("R_GetTexTypeInfo: RGB format has no alpha, TEXF_ALPHA not allowed\n"); + return NULL; + case TEXTYPE_RGBA: + return &textype_rgba_alpha; + default: + Host_Error("R_GetTexTypeInfo: unknown texture format\n"); + return NULL; + } + } + else + { + switch(textype) + { + 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; + } + } +} + +static void R_UploadTexture(gltexture_t *t); + +static void R_PrecacheTexture(gltexture_t *glt) +{ + int precache; + precache = false; + if (glt->flags & TEXF_ALWAYSPRECACHE) + precache = true; + else if (r_precachetextures.integer >= 2) + precache = true; + else if (r_precachetextures.integer >= 1) + if (glt->flags & TEXF_PRECACHE) + precache = true; + + if (precache) + R_UploadTexture(glt); +} + +int R_RealGetTexture(rtexture_t *rt) +{ + if (rt) + { + gltexture_t *glt; + glt = (gltexture_t *)rt; + if (glt->flags & GLTEXF_UPLOAD) + R_UploadTexture(glt); + glt->texnum = glt->image->texnum; + return glt->image->texnum; + } + else return 0; +} + +void R_FreeTexture(rtexture_t *rt) +{ + gltexture_t *glt, **gltpointer; + gltextureimage_t *image, **gltimagepointer; + glt = (gltexture_t *)rt; - if (!(glt->internalflags & GLTEXF_UPLOADED)) + if (glt == NULL) + Host_Error("R_FreeTexture: texture == NULL\n"); + + 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); + + // 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) { - GL_UploadTexture(glt); - if (!(glt->internalflags & GLTEXF_UPLOADED)) - Host_Error("R_GetTexture: unable to upload texture\n"); + 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, &image->texnum); + if (image->blockallocation) + Mem_Free(image->blockallocation); + Mem_Free(image); + } } - return glt->texnum; + + if (glt->identifier) + Mem_Free(glt->identifier); + if (glt->inputtexels) + Mem_Free(glt->inputtexels); + Mem_Free(glt); } +/* +static gltexture_t *R_FindTexture (gltexturepool_t *pool, char *identifier) +{ + gltexture_t *glt; + + if (!identifier) + return NULL; + + for (glt = pool->gltchain;glt;glt = glt->chain) + if (glt->identifier && !strcmp (identifier, glt->identifier)) + return glt; + + return NULL; +} +*/ + +rtexturepool_t *R_AllocTexturePool(void) +{ + gltexturepool_t *pool; + if (texturemempool == NULL) + return NULL; + pool = Mem_Alloc(texturemempool, sizeof(gltexturepool_t)); + if (pool == NULL) + return NULL; + pool->next = gltexturepoolchain; + gltexturepoolchain = pool; + pool->sentinel = TEXTUREPOOL_SENTINEL; + return (rtexturepool_t *)pool; +} + +void R_FreeTexturePool(rtexturepool_t **rtexturepool) +{ + gltexturepool_t *pool, **poolpointer; + if (rtexturepool == NULL) + return; + if (*rtexturepool == NULL) + return; + pool = (gltexturepool_t *)(*rtexturepool); + *rtexturepool = NULL; + if (pool->sentinel != TEXTUREPOOL_SENTINEL) + Host_Error("R_FreeTexturePool: pool already freed\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) + Sys_Error("R_FreeTexturePool: not all images freed\n"); + Mem_Free(pool); +} + + typedef struct { char *name; - int minimize, maximize; -} glmode_t; + int minification, magnification; +} +glmode_t; -glmode_t modes[] = +static glmode_t modes[] = { {"GL_NEAREST", GL_NEAREST, GL_NEAREST}, {"GL_LINEAR", GL_LINEAR, GL_LINEAR}, @@ -69,657 +325,899 @@ 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; + gltextureimage_t *image; + 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); return; } + } Con_Printf ("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"); 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 (image = pool->imagechain;image;image = image->imagechain) { - 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 (!(image->flags & GLTEXF_UPLOAD) && !(image->flags & (TEXF_FORCENEAREST | TEXF_FORCELINEAR))) + { + 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 + 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); + } } } } -void GL_TextureStats_Print(char *name, int total, int total2, int loaded, int crc, int mip, int alpha, int total2valid) +static int R_CalcTexelDataSize (gltexture_t *glt) { - 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 width2, height2, depth2, size; + if (glt->flags & TEXF_FRAGMENT) + size = glt->width * glt->height * glt->depth; + else + { + if (r_max_size.integer > realmaxsize) + Cvar_SetValue("r_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 >>= r_picmip.integer;width2 > r_max_size.integer;width2 >>= 1); + for (height2 >>= r_picmip.integer;height2 > r_max_size.integer;height2 >>= 1); + for (depth2 >>= r_picmip.integer;depth2 > r_max_size.integer;depth2 >>= 1); + if (width2 < 1) width2 = 1; + if (height2 < 1) height2 = 1; + if (depth2 < 1) depth2 = 1; + + size = 0; + if (glt->flags & TEXF_MIPMAP) + { + while (width2 > 1 || height2 > 1 || depth2 > 1) + { + 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; } -void GL_TextureStats_PrintTotal(void) +void R_TextureStats_PrintTotal(void) { - int i, t = 0, p = 0, loaded = 0, loadedt = 0, loadedp = 0; + int glsize, total = 0, totalt = 0, totalp = 0, loaded = 0, loadedt = 0, loadedp = 0; gltexture_t *glt; - for (i = 0, glt = gltextures;i < numgltextures;i++, glt++) + gltexturepool_t *pool; + for (pool = gltexturepoolchain;pool;pool = pool->next) { - t += glt->texeldatasize; - p += glt->inputtexeldatasize; - if (glt->internalflags & GLTEXF_UPLOADED) + for (glt = pool->gltchain;glt;glt = glt->chain) { - loaded++; - loadedt += glt->texeldatasize; - loadedp += glt->inputtexeldatasize; + glsize = R_CalcTexelDataSize(glt); + total++; + totalt += glsize; + totalp += glt->inputdatasize; + if (!(glt->flags & GLTEXF_UPLOAD)) + { + loaded++; + loadedt += glsize; + loadedp += glt->inputdatasize; + } } } - 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); + Con_Printf("total: %i (%.3fMB, %.3fMB original), uploaded %i (%.3fMB, %.3fMB original), upload on demand %i (%.3fMB, %.3fMB original)\n", total, totalt / 1048576.0, totalp / 1048576.0, loaded, loadedt / 1048576.0, loadedp / 1048576.0, total - loaded, (totalt - loadedt) / 1048576.0, (totalp - loadedp) / 1048576.0); } -void GL_TextureStats_f(void) +static void R_TextureStats_f(void) { - int i; + int loaded; 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; + Con_Printf("glsize input loaded mip alpha name\n"); + for (pool = gltexturepoolchain;pool;pool = pool->next) + { + for (glt = pool->gltchain;glt;glt = glt->chain) + { + loaded = !(glt->flags & GLTEXF_UPLOAD); + Con_Printf("%c%4i%c%c%4i%c %s %s %s %s\n", loaded ? '[' : ' ', (R_CalcTexelDataSize(glt) + 1023) / 1024, loaded ? ']' : ' ', glt->inputtexels ? '[' : ' ', (glt->inputdatasize + 1023) / 1024, glt->inputtexels ? ']' : ' ', loaded ? "loaded" : " ", (glt->flags & TEXF_MIPMAP) ? "mip" : " ", (glt->flags & TEXF_ALPHA) ? "alpha" : " ", glt->identifier ? glt->identifier : ""); + } + Con_Printf("pool %10p\n", pool); + } + R_TextureStats_PrintTotal(); } char engineversion[40]; -//void GL_UploadTexture (gltexture_t *glt); -void r_textures_start(void) +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; } + if (colorconvertbuffer) + { + Mem_Free(colorconvertbuffer); + colorconvertbuffer = NULL; + } +} - return -1; +void R_MakeResizeBufferBigger(int size) +{ + if (resizebuffersize < size) + { + resizebuffersize = size; + if (resizebuffer) + Mem_Free(resizebuffer); + if (colorconvertbuffer) + Mem_Free(colorconvertbuffer); + resizebuffer = Mem_Alloc(textureprocessingmempool, resizebuffersize); + colorconvertbuffer = Mem_Alloc(textureprocessingmempool, resizebuffersize); + if (!resizebuffer || !colorconvertbuffer) + Host_Error("R_Upload: out of memory\n"); + } } -void R_ResampleTextureLerpLine (byte *in, byte *out, int inwidth, int outwidth) +static void GL_SetupTextureParameters(int flags, int texturetype) { - 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) + int textureenum = gltexturetypeenums[texturetype]; + int wrapmode = ((flags & TEXF_CLAMP) && gl_support_clamptoedge) ? GL_CLAMP_TO_EDGE : GL_REPEAT; + + CHECKGLERROR + + if (gl_support_anisotropy) + qglTexParameterf(textureenum, GL_TEXTURE_MAX_ANISOTROPY_EXT, gl_texture_anisotropy.value); + qglTexParameteri(textureenum, GL_TEXTURE_WRAP_S, wrapmode); + qglTexParameteri(textureenum, GL_TEXTURE_WRAP_T, wrapmode); + if (gltexturetypedimensions[texturetype] >= 3) + qglTexParameteri(textureenum, GL_TEXTURE_WRAP_R, wrapmode); + + if (flags & TEXF_FORCENEAREST) { - 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 + if (flags & TEXF_MIPMAP) + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); + else + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + else if (flags & TEXF_FORCELINEAR) + { + if (flags & TEXF_MIPMAP) { - *out++ = in[0]; - *out++ = in[1]; - *out++ = in[2]; - *out++ = in[3]; + 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); + else + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST); } + else + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + } + else + { + if (flags & TEXF_MIPMAP) + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, gl_filter_min); + else + qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, gl_filter_mag); + qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, gl_filter_mag); } + + CHECKGLERROR } -/* -================ -R_ResampleTexture -================ -*/ -void R_ResampleTexture (void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight) +static void R_Upload(gltexture_t *glt, qbyte *data) { - if (r_lerpimages.value) + int i, mip, width, height, depth; + GLint oldbindtexnum; + qbyte *prevbuffer; + prevbuffer = data; + + CHECKGLERROR + + 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) { - int i, j, yi, oldy, f, fstep, endy = (inheight-1); - byte *inrow, *out, *row1, *row2; - out = outdata; - fstep = (int) (inheight*65536.0f/outheight); - - 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) + if (glt->image->flags & GLTEXF_UPLOAD) { - yi = f >> 16; - if (yi < endy) - { - int lerp = f & 0xFFFF; - 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); - R_ResampleTextureLerpLine (inrow + inwidth*4, row2, inwidth, outwidth); - oldy = yi; - } - j = outwidth - 4; - while(j >= 0) - { - 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; - j -= 4; - } - if (j & 2) - { - 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; - row1 += 8; - row2 += 8; - } - if (j & 1) - { - 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; - row1 += 4; - row2 += 4; - } - row1 -= outwidth*4; - row2 -= outwidth*4; - } - else + glt->image->flags &= ~GLTEXF_UPLOAD; + Con_DPrintf("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) { - 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; - } - memcpy(out, row1, outwidth * 4); + 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 (prevbuffer == NULL) + { + R_MakeResizeBufferBigger(glt->image->width * glt->image->height * glt->image->depth * glt->image->bytesperpixel); + memset(resizebuffer, 255, 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; } - 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++) + 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) { - inrow = (int *)indata + inwidth*(i*inheight/outheight); - frac = fracstep >> 1; - j = outwidth - 4; - while(j >= 0) + width = glt->image->width; + height = glt->image->height; + depth = glt->image->depth; + memset(resizebuffer, 255, width * height * depth * glt->image->bytesperpixel); + prevbuffer = resizebuffer; + } + else + { + if (glt->textype->textype == TEXTYPE_PALETTE) { - 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; - j--; + // 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; } - if (j & 2) + } + + // cubemaps contain multiple images and thus get processed a bit differently + if (glt->image->texturetype != GLTEXTURETYPE_CUBEMAP) + { + if (glt->width != width || glt->height != height || glt->depth != depth) { - out[0] = inrow[frac >> 16];frac += fracstep; - out[1] = inrow[frac >> 16];frac += fracstep; - out += 2; + Image_Resample(prevbuffer, glt->width, glt->height, glt->depth, resizebuffer, width, height, depth, glt->image->bytesperpixel, r_lerpimages.integer); + prevbuffer = resizebuffer; } - if (j & 1) + // picmip/max_size + while (width > glt->image->width || height > glt->image->height || depth > glt->image->depth) { - out[0] = inrow[frac >> 16];frac += fracstep; - out += 1; + Image_MipReduce(prevbuffer, resizebuffer, &width, &height, &depth, glt->image->width, glt->image->height, glt->image->depth, glt->image->bytesperpixel); + prevbuffer = resizebuffer; } } - } -} - -// in can be the same as out -void GL_MipReduce(byte *in, byte *out, int width, int height, int destwidth, int destheight) -{ - int x, y, width2, height2, nextrow; - if (width > destwidth) - { - if (height > destheight) + mip = 0; + switch(glt->image->texturetype) { - // reduce both - width2 = width >> 1; - height2 = height >> 1; - nextrow = width << 2; - for (y = 0;y < height2;y++) + case GLTEXTURETYPE_1D: + qglTexImage1D(GL_TEXTURE_1D, mip++, glt->image->glinternalformat, width, 0, glt->image->glformat, GL_UNSIGNED_BYTE, prevbuffer); + CHECKGLERROR + if (glt->flags & TEXF_MIPMAP) { - for (x = 0;x < width2;x++) + while (width > 1 || height > 1 || depth > 1) { - out[0] = (byte) ((in[0] + in[4] + in[nextrow ] + in[nextrow+4]) >> 2); - out[1] = (byte) ((in[1] + in[5] + in[nextrow+1] + in[nextrow+5]) >> 2); - out[2] = (byte) ((in[2] + in[6] + in[nextrow+2] + in[nextrow+6]) >> 2); - out[3] = (byte) ((in[3] + in[7] + in[nextrow+3] + in[nextrow+7]) >> 2); - out += 4; - in += 8; + Image_MipReduce(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1, glt->image->bytesperpixel); + prevbuffer = resizebuffer; + qglTexImage1D(GL_TEXTURE_1D, mip++, glt->image->glinternalformat, width, 0, glt->image->glformat, GL_UNSIGNED_BYTE, prevbuffer); + CHECKGLERROR } - in += nextrow; // skip a line } - } - else - { - // reduce width - width2 = width >> 1; - for (y = 0;y < height;y++) + break; + case GLTEXTURETYPE_2D: + qglTexImage2D(GL_TEXTURE_2D, mip++, glt->image->glinternalformat, width, height, 0, glt->image->glformat, GL_UNSIGNED_BYTE, prevbuffer); + CHECKGLERROR + if (glt->flags & TEXF_MIPMAP) { - for (x = 0;x < width2;x++) + while (width > 1 || height > 1 || depth > 1) { - out[0] = (byte) ((in[0] + in[4]) >> 1); - out[1] = (byte) ((in[1] + in[5]) >> 1); - out[2] = (byte) ((in[2] + in[6]) >> 1); - out[3] = (byte) ((in[3] + in[7]) >> 1); - out += 4; - in += 8; + Image_MipReduce(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1, glt->image->bytesperpixel); + prevbuffer = resizebuffer; + qglTexImage2D(GL_TEXTURE_2D, mip++, glt->image->glinternalformat, width, height, 0, glt->image->glformat, GL_UNSIGNED_BYTE, prevbuffer); + CHECKGLERROR } } - } - } - else - { - if (height > destheight) - { - // reduce height - height2 = height >> 1; - nextrow = width << 2; - for (y = 0;y < height2;y++) + break; + case GLTEXTURETYPE_3D: + qglTexImage3D(GL_TEXTURE_3D, mip++, glt->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++) { - for (x = 0;x < width;x++) + 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) { - 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; + 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 + } } - in += nextrow; // skip a line } + break; } - else - Sys_Error("GL_MipReduce: desired size already achieved\n"); + GL_SetupTextureParameters(glt->image->flags, glt->image->texturetype); } + qglBindTexture(gltexturetypeenums[glt->image->texturetype], oldbindtexnum); } -void GL_Upload32(int glslot, byte *data, int width, int height, int flags) +static void R_FindImageForTexture(gltexture_t *glt) { - int mip, width2, height2, width3, height3, internalformat; - byte *gammadata, *buffer; - - 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; - - gammadata = qmalloc(width*height*4); - buffer = qmalloc(width2*height2*4); - if (!gammadata || !buffer) - Host_Error("GL_Upload32: out of memory\n"); - - Image_CopyRGBAGamma(data, gammadata, width*height); - - R_ResampleTexture(gammadata, width, height, buffer, width2, height2); - - qfree(gammadata); - - while (width2 > width3 || height2 > height3) - { - GL_MipReduce(buffer, buffer, width2, height2, width3, height3); - - if (width2 > width3) - width2 >>= 1; - if (height2 > height3) - height2 >>= 1; - } - - 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) + int i, j, best, best2, x, y, z, w, h, d; + 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) { - while (width2 > 1 || height2 > 1) + for (imagechainpointer = &pool->imagechain;*imagechainpointer;imagechainpointer = &(*imagechainpointer)->imagechain) { - GL_MipReduce(buffer, buffer, width2, height2, 1, 1); + 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)) + 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 (best2 = 0, j = 0;j < w;j++) + { + if (image->blockallocation[i+j] >= best) + break; + if (best2 < image->blockallocation[i+j]) + best2 = image->blockallocation[i+j]; + } + if (j == w) + { + // this is a valid spot + x = i; + y = best = best2; + } + } + + if (best + h > image->height) + continue; - if (width2 > 1) - width2 >>= 1; - if (height2 > 1) - height2 >>= 1; + for (i = 0;i < w;i++) + image->blockallocation[x + i] = best + h; - glTexImage2D(GL_TEXTURE_2D, mip++, internalformat, width2, height2, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer); + glt->x = x; + glt->y = y; + glt->z = 0; + glt->image = image; + image->texturecount++; + return; } - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + image = Mem_Alloc(texturemempool, sizeof(gltextureimage_t)); + if (image == NULL) + Sys_Error("R_FindImageForTexture: ran out of memory\n"); + 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 = 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 { - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max); - glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); + for (imagechainpointer = &pool->imagechain;*imagechainpointer;imagechainpointer = &(*imagechainpointer)->imagechain); + + image = Mem_Alloc(texturemempool, sizeof(gltextureimage_t)); + if (image == NULL) + Sys_Error("R_FindImageForTexture: ran out of memory\n"); + image->type = GLIMAGETYPE_TILE; + image->blockallocation = NULL; + + // calculate final size + if (r_max_size.integer > realmaxsize) + Cvar_SetValue("r_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 >>= r_picmip.integer;image->width > r_max_size.integer;image->width >>= 1); + for (image->height >>= r_picmip.integer;image->height > r_max_size.integer;image->height >>= 1); + for (image->depth >>= r_picmip.integer;image->depth > r_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; } - glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); - - qfree(buffer); -} - -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); + image->texturetype = glt->texturetype; + image->glinternalformat = texinfo->glinternalformat; + image->glformat = texinfo->glformat; + image->flags = (glt->flags & (TEXF_MIPMAP | TEXF_ALPHA | TEXF_CLAMP)) | GLTEXF_UPLOAD; + image->bytesperpixel = texinfo->internalbytesperpixel; + image->sides = image->texturetype == GLTEXTURETYPE_CUBEMAP ? 6 : 1; + // get a texture number to use + qglGenTextures(1, &image->texnum); + *imagechainpointer = image; + image->texturecount++; + + glt->x = x; + glt->y = y; + glt->y = 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) { - if (glt->inputtexels == NULL) + if (!(glt->flags & GLTEXF_UPLOAD)) 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) + + R_Upload(glt, glt->inputtexels); + if (glt->inputtexels) { - while (width2 > 1 || height2 > 1) - { - size += width2 * height2; - if (width2 > 1) - width2 >>= 1; - if (height2 > 1) - height2 >>= 1; - } - size++; // count the last 1x1 mipmap + Mem_Free(glt->inputtexels); + glt->inputtexels = NULL; + glt->flags |= GLTEXF_DESTROYED; } - else - size = width2*height2; - - size *= 4; // RGBA - - return size; + 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, int textype, int texturetype, const qbyte *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 (flags & TEXF_FRAGMENT && texturetype != GLTEXTURETYPE_2D) + Sys_Error("R_LoadTexture: only 2D fragment textures implemented\n"); + if (texturetype == GLTEXTURETYPE_CUBEMAP && !gl_texturecubemap) + Sys_Error("R_LoadTexture: cubemap texture not supported by driver\n"); + if (texturetype == GLTEXTURETYPE_3D && !gl_texture3d) + Sys_Error("R_LoadTexture: 3d texture not supported by driver\n"); + + /* + glt = R_FindTexture (pool, identifier); + if (glt) + { + Con_Printf("R_LoadTexture: replacing existing texture %s\n", identifier); + R_FreeTexture((rtexture_t *)glt); + } + */ + + texinfo = R_GetTexTypeInfo(textype, flags); + size = width * height * depth * sides * texinfo->inputbytesperpixel; + if (size < 1) + Sys_Error("R_LoadTexture: bogus texture size (%dx%dx%dx%dbppx%dsides = %d bytes)\n", width, height, depth, texinfo->inputbytesperpixel * 8, sides); // 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 (((qbyte *)&palette[data[i]])[3] < 255) + { + flags |= TEXF_ALPHA; + break; + } } } } - else + 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) { - 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; + case TEXTYPE_DSDT: + break; + default: + Host_Error("R_LoadTexture: unknown texture type\n"); } - if (flags & TEXF_RGBA) - bytesperpixel = 4; - else - bytesperpixel = 1; - - internalflags = 0; - if (r_lerpimages.value != 0) - internalflags |= GLTEXF_LERPED; - - // 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; - } - } - -/* - if (freeglt) - { - glt = freeglt; + glt->identifier = Mem_Alloc(texturemempool, strlen(identifier)+1); 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->identifier = NULL; + glt->pool = pool; + glt->chain = pool->gltchain; + pool->gltchain = glt; glt->width = width; glt->height = height; - glt->flags = flags; - glt->internalflags = internalflags; + glt->depth = depth; + glt->flags = flags | GLTEXF_UPLOAD; + glt->textype = texinfo; + glt->texturetype = texturetype; + glt->inputdatasize = size; + glt->palette = palette; + + if (data) + { + glt->inputtexels = Mem_Alloc(texturedatamempool, size); + if (glt->inputtexels == NULL) + Sys_Error("R_LoadTexture: out of memory\n"); + memcpy(glt->inputtexels, data, size); + } + else + glt->inputtexels = NULL; - if (glt->inputtexels) - qfree(glt->inputtexels); - glt->inputtexeldatasize = width*height*bytesperpixel; - glt->inputtexels = qmalloc(glt->inputtexeldatasize); + R_FindImageForTexture(glt); + R_PrecacheTexture(glt); - memcpy(glt->inputtexels, data, glt->inputtexeldatasize); + return (rtexture_t *)glt; +} - glt->texeldatasize = R_CalcTexelDataSize(width, height, flags & TEXF_MIPMAP); +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); +} - precache = false; - if (flags & TEXF_ALWAYSPRECACHE) - precache = true; - else if (r_precachetextures.value >= 1) +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) { - if (flags & TEXF_PRECACHE) - precache = true; - if (r_precachetextures.value >= 2) - precache = true; + 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; + } + return; + } + if (!rt) + Host_Error("R_FragmentLocation: no texture supplied\n"); + glt = (gltexture_t *)rt; + if (glt->flags & TEXF_FRAGMENT) + { + if (x) + *x = glt->x; + if (y) + *y = glt->y; + if (fx1 || fy1 || fx2 || fy2) + { + 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 + { + 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; + } } +} - if (precache) - GL_UploadTexture(glt); +void R_FragmentLocation(rtexture_t *rt, int *x, int *y, float *fx1, float *fy1, float *fx2, float *fy2) +{ + R_FragmentLocation3D(rt, x, y, NULL, fx1, fy1, NULL, fx2, fy2, NULL); +} - return (rtexture_t *)glt; +int R_CompatibleFragmentWidth(int width, int textype, int flags) +{ + return width; } -// only used for lightmaps -int R_GetTextureSlots(int count) +void R_UpdateTexture(rtexture_t *rt, qbyte *data) { - int i; - i = gl_texture_number; - gl_texture_number += count; - return i; + 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); } +