+
#include "quakedef.h"
+#include "image.h"
+#include "jpeg.h"
+#include "image_png.h"
+#include "intoverflow.h"
+
+cvar_t gl_max_size = {CVAR_SAVE, "gl_max_size", "2048", "maximum allowed texture size, can be used to reduce video memory usage, limited by hardware capabilities (typically 2048, 4096, or 8192)"};
+cvar_t gl_max_lightmapsize = {CVAR_SAVE, "gl_max_lightmapsize", "1024", "maximum allowed texture size for lightmap textures, use larger values to improve rendering speed, as long as there is enough video memory available (setting it too high for the hardware will cause very bad performance)"};
+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 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)"};
+cvar_t gl_texturecompression_reflectmask = {CVAR_SAVE, "gl_texturecompression_reflectmask", "1", "whether to compress reflection cubemap masks (mask of which areas of the texture should reflect the generic shiny cubemap)"};
+cvar_t gl_nopartialtextureupdates = {CVAR_SAVE, "gl_nopartialtextureupdates", "1", "use alternate path for dynamic lightmap updates that avoids a possibly slow code path in the driver"};
+
+int gl_filter_min = GL_LINEAR_MIPMAP_LINEAR;
+int gl_filter_mag = GL_LINEAR;
+
+
+static mempool_t *texturemempool;
+static memexpandablearray_t texturearray;
+
+// note: this must not conflict with TEXF_ flags in r_textures.h
+// bitmask for mismatch checking
+#define GLTEXF_IMPORTANTBITS (0)
+// dynamic texture (treat texnum == 0 differently)
+#define GLTEXF_DYNAMIC 0x00080000
+
+typedef struct textypeinfo_s
+{
+ textype_t textype;
+ int inputbytesperpixel;
+ int internalbytesperpixel;
+ float glinternalbytesperpixel;
+ int glinternalformat;
+ int glformat;
+ int gltype;
+}
+textypeinfo_t;
+
+
+static textypeinfo_t textype_palette = {TEXTYPE_PALETTE , 1, 4, 4.0f, 3 , GL_BGRA , GL_UNSIGNED_BYTE };
+static textypeinfo_t textype_palette_alpha = {TEXTYPE_PALETTE , 1, 4, 4.0f, 4 , GL_BGRA , GL_UNSIGNED_BYTE };
+static textypeinfo_t textype_rgba = {TEXTYPE_RGBA , 4, 4, 4.0f, 3 , GL_RGBA , GL_UNSIGNED_BYTE };
+static textypeinfo_t textype_rgba_alpha = {TEXTYPE_RGBA , 4, 4, 4.0f, 4 , GL_RGBA , GL_UNSIGNED_BYTE };
+static textypeinfo_t textype_rgba_compress = {TEXTYPE_RGBA , 4, 4, 0.5f, GL_COMPRESSED_RGB_S3TC_DXT1_EXT , GL_RGBA , GL_UNSIGNED_BYTE };
+static textypeinfo_t textype_rgba_alpha_compress = {TEXTYPE_RGBA , 4, 4, 1.0f, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_RGBA , GL_UNSIGNED_BYTE };
+static textypeinfo_t textype_bgra = {TEXTYPE_BGRA , 4, 4, 4.0f, 3 , GL_BGRA , GL_UNSIGNED_BYTE };
+static textypeinfo_t textype_bgra_alpha = {TEXTYPE_BGRA , 4, 4, 4.0f, 4 , GL_BGRA , GL_UNSIGNED_BYTE };
+static textypeinfo_t textype_bgra_compress = {TEXTYPE_BGRA , 4, 4, 0.5f, GL_COMPRESSED_RGB_S3TC_DXT1_EXT , GL_BGRA , GL_UNSIGNED_BYTE };
+static textypeinfo_t textype_bgra_alpha_compress = {TEXTYPE_BGRA , 4, 4, 1.0f, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_BGRA , GL_UNSIGNED_BYTE };
+static textypeinfo_t textype_shadowmap16 = {TEXTYPE_SHADOWMAP , 2, 2, 2.0f, GL_DEPTH_COMPONENT16_ARB , GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT};
+static textypeinfo_t textype_shadowmap24 = {TEXTYPE_SHADOWMAP , 4, 4, 4.0f, GL_DEPTH_COMPONENT24_ARB , GL_DEPTH_COMPONENT, GL_UNSIGNED_INT };
+static textypeinfo_t textype_alpha = {TEXTYPE_ALPHA , 1, 4, 4.0f, GL_ALPHA , GL_ALPHA , GL_UNSIGNED_BYTE };
+static textypeinfo_t textype_dxt1 = {TEXTYPE_DXT1 , 4, 0, 0.5f, GL_COMPRESSED_RGB_S3TC_DXT1_EXT , 0 , 0 };
+static textypeinfo_t textype_dxt1a = {TEXTYPE_DXT1A , 4, 0, 0.5f, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 0 , 0 };
+static textypeinfo_t textype_dxt3 = {TEXTYPE_DXT3 , 4, 0, 1.0f, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 0 , 0 };
+static textypeinfo_t textype_dxt5 = {TEXTYPE_DXT5 , 4, 0, 1.0f, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 0 , 0 };
+static textypeinfo_t textype_colorbuffer = {TEXTYPE_COLORBUFFER, 4, 4, 4.0f, 4 , GL_BGRA , GL_UNSIGNED_BYTE };
+
+
+typedef enum gltexturetype_e
+{
+ GLTEXTURETYPE_2D,
+ GLTEXTURETYPE_3D,
+ GLTEXTURETYPE_CUBEMAP,
+ GLTEXTURETYPE_RECTANGLE,
+ GLTEXTURETYPE_TOTAL
+}
+gltexturetype_t;
-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};
+static int gltexturetypeenums[GLTEXTURETYPE_TOTAL] = {GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_RECTANGLE_ARB};
+static int gltexturetypedimensions[GLTEXTURETYPE_TOTAL] = {2, 3, 2, 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 portion of the struct is exposed to the R_GetTexture macro for
+ // speed reasons, must be identical in rtexture_t!
+ int texnum; // GL texture slot number
+ qboolean dirty; // indicates that R_RealGetTexture should be called
+ int gltexturetypeenum; // used by R_Mesh_TexBind
+
+ // dynamic texture stuff [11/22/2007 Black]
+ updatecallback_t updatecallback;
+ void *updatacallback_data;
+ // --- [11/22/2007 Black]
+
+ // stores backup copy of texture for deferred texture updates (gl_nopartialtextureupdates cvar)
+ unsigned char *bufferpixels;
+ qboolean buffermodified;
+
+ // 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 vid.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 or GL_DEPTH_COMPONENT
+ int glformat;
+ // 3 or 4
+ int glinternalformat;
+ // GL_UNSIGNED_BYTE or GL_UNSIGNED_INT or GL_UNSIGNED_SHORT or GL_FLOAT
+ int gltype;
+}
+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;
-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;
+ switch(textype)
+ {
+ case TEXTYPE_DXT1:
+ return &textype_dxt1;
+ case TEXTYPE_DXT1A:
+ return &textype_dxt1a;
+ case TEXTYPE_DXT3:
+ return &textype_dxt3;
+ case TEXTYPE_DXT5:
+ return &textype_dxt5;
+ case TEXTYPE_PALETTE:
+ return (flags & TEXF_ALPHA) ? &textype_palette_alpha : &textype_palette;
+ case TEXTYPE_RGBA:
+ if ((flags & TEXF_COMPRESS) && gl_texturecompression.integer >= 1 && vid.support.arb_texture_compression)
+ return (flags & TEXF_ALPHA) ? &textype_rgba_alpha_compress : &textype_rgba_compress;
+ return (flags & TEXF_ALPHA) ? &textype_rgba_alpha : &textype_rgba;
+ case TEXTYPE_BGRA:
+ if ((flags & TEXF_COMPRESS) && gl_texturecompression.integer >= 1 && vid.support.arb_texture_compression)
+ return (flags & TEXF_ALPHA) ? &textype_bgra_alpha_compress : &textype_bgra_compress;
+ return (flags & TEXF_ALPHA) ? &textype_bgra_alpha : &textype_bgra;
+ case TEXTYPE_ALPHA:
+ return &textype_alpha;
+ case TEXTYPE_SHADOWMAP:
+ return (flags & TEXF_LOWPRECISION) ? &textype_shadowmap16 : &textype_shadowmap24;
+ case TEXTYPE_COLORBUFFER:
+ return &textype_colorbuffer;
+ default:
+ Host_Error("R_GetTexTypeInfo: unknown texture format");
+ break;
+ }
+ return NULL;
+}
+
+// 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->flags & GLTEXF_DYNAMIC)
+ {
+ // mark it as dirty, so R_RealGetTexture gets called
+ glt->dirty = true;
+ }
+}
+
+void R_MakeTextureDynamic(rtexture_t *rt, updatecallback_t updatecallback, void *data) {
+ gltexture_t *glt = (gltexture_t*) rt;
+ if( !glt ) {
+ return;
+ }
+
+ glt->flags |= GLTEXF_DYNAMIC;
+ glt->updatecallback = updatecallback;
+ glt->updatacallback_data = data;
+}
-#define MAX_GLTEXTURES 4096
-gltexture_t *gltextures;
-unsigned int numgltextures = 0, gl_texture_number = 1;
+static void R_UpdateDynamicTexture(gltexture_t *glt) {
+ glt->dirty = false;
+ if( glt->updatecallback ) {
+ glt->updatecallback( (rtexture_t*) glt, glt->updatacallback_data );
+ }
+}
-void GL_UploadTexture(gltexture_t *t);
+void R_PurgeTexture(rtexture_t *rt)
+{
+ if(rt && !(((gltexture_t*) rt)->flags & TEXF_PERSISTENT)) {
+ R_FreeTexture(rt);
+ }
+}
-int R_GetTexture(rtexture_t *rt)
+void R_FreeTexture(rtexture_t *rt)
{
- gltexture_t *glt;
- if (!rt)
- return 0;
+ 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->texnum)
{
- 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_ExpandableArray_FreeRecord(&texturearray, glt);
+}
+
+rtexturepool_t *R_AllocTexturePool(void)
+{
+ gltexturepool_t *pool;
+ if (texturemempool == NULL)
+ return NULL;
+ pool = (gltexturepool_t *)Mem_Alloc(texturemempool, sizeof(gltexturepool_t));
+ if (pool == NULL)
+ return NULL;
+ pool->next = gltexturepoolchain;
+ gltexturepoolchain = pool;
+ pool->sentinel = TEXTUREPOOL_SENTINEL;
+ return (rtexturepool_t *)pool;
+}
+
+void R_FreeTexturePool(rtexturepool_t **rtexturepool)
+{
+ gltexturepool_t *pool, **poolpointer;
+ if (rtexturepool == NULL)
+ return;
+ if (*rtexturepool == NULL)
+ return;
+ pool = (gltexturepool_t *)(*rtexturepool);
+ *rtexturepool = NULL;
+ if (pool->sentinel != TEXTUREPOOL_SENTINEL)
+ Host_Error("R_FreeTexturePool: pool already freed");
+ for (poolpointer = &gltexturepoolchain;*poolpointer && *poolpointer != pool;poolpointer = &(*poolpointer)->next);
+ if (*poolpointer == pool)
+ *poolpointer = pool->next;
+ else
+ Host_Error("R_FreeTexturePool: pool not linked");
+ while (pool->gltchain)
+ R_FreeTexture((rtexture_t *)pool->gltchain);
+ Mem_Free(pool);
}
-typedef struct
+
+typedef struct glmode_s
{
char *name;
- int minimize, maximize;
-} glmode_t;
+ int minification, magnification;
+}
+glmode_t;
-glmode_t modes[] =
+static glmode_t modes[6] =
{
{"GL_NEAREST", GL_NEAREST, GL_NEAREST},
{"GL_LINEAR", GL_LINEAR, GL_LINEAR},
{"GL_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 ; i<numgltextures ; i++, glt++)
+ // FIXME: force renderer(/client/something?) restart instead?
+ CHECKGLERROR
+ GL_ActiveTexture(0);
+ for (pool = gltexturepoolchain;pool;pool = pool->next)
{
- 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->texnum && !(glt->flags & (TEXF_FORCENEAREST | TEXF_FORCELINEAR)))
+ {
+ oldbindtexnum = R_Mesh_TexBound(0, gltexturetypeenums[glt->texturetype]);
+ 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 = "<unnamed>";
- 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;
+
+ switch (texturetype)
+ {
+ default:
+ case GLTEXTURETYPE_2D:
+ maxsize = vid.maxtexturesize_2d;
+ if (flags & TEXF_PICMIP)
+ {
+ maxsize = bound(1, gl_max_size.integer, maxsize);
+ picmip = gl_picmip.integer;
+ }
+ break;
+ case GLTEXTURETYPE_3D:
+ maxsize = vid.maxtexturesize_3d;
+ break;
+ case GLTEXTURETYPE_CUBEMAP:
+ maxsize = vid.maxtexturesize_cubemap;
+ break;
+ }
+
+ if (outwidth)
+ {
+ if (vid.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 (vid.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 (vid.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->texnum != 0;
+ 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", (void *)pool, pooltotal, pooltotalt / 1048576.0, pooltotalp / 1048576.0, poolloaded, poolloadedt / 1048576.0, poolloadedp / 1048576.0, pooltotal - poolloaded, (pooltotalt - poolloadedt) / 1048576.0, (pooltotalp - poolloadedp) / 1048576.0);
+ 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(void)
+static void r_textures_start(void)
{
-// int i;
-// gltexture_t *glt;
-// for (i=0, glt=gltextures ; i<numgltextures ; i++, glt++)
-// GL_UploadTexture(glt);
+ // LordHavoc: allow any alignment
+ CHECKGLERROR
+ qglPixelStorei(GL_UNPACK_ALIGNMENT, 1);CHECKGLERROR
+ qglPixelStorei(GL_PACK_ALIGNMENT, 1);CHECKGLERROR
+
+ texturemempool = Mem_AllocPool("texture management", 0, NULL);
+ Mem_ExpandableArray_NewArray(&texturearray, texturemempool, sizeof(gltexture_t), 512);
+
+ // Disable JPEG screenshots if the DLL isn't loaded
+ if (! JPEG_OpenLibrary ())
+ Cvar_SetValueQuick (&scr_screenshot_jpeg, 0);
+ // TODO: support png screenshots?
+ PNG_OpenLibrary ();
}
-void r_textures_shutdown(void)
+static void r_textures_shutdown(void)
{
+ rtexturepool_t *temp;
+
+ JPEG_CloseLibrary ();
+
+ while(gltexturepoolchain)
+ {
+ temp = (rtexturepool_t *) gltexturepoolchain;
+ R_FreeTexturePool(&temp);
+ }
+
+ resizebuffersize = 0;
+ resizebuffer = NULL;
+ colorconvertbuffer = NULL;
+ texturebuffer = NULL;
+ Mem_ExpandableArray_FreeArray(&texturearray);
+ Mem_FreePool(&texturemempool);
}
-void r_textures_newmap(void)
+static void r_textures_newmap(void)
{
}
void R_Textures_Init (void)
{
- Cmd_AddCommand("r_texturestats", GL_TextureStats_f);
- Cvar_RegisterVariable (&r_max_size);
- Cvar_RegisterVariable (&r_picmip);
+ Cmd_AddCommand("gl_texturemode", &GL_TextureMode_f, "set texture filtering mode (GL_NEAREST, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, etc)");
+ Cmd_AddCommand("r_texturestats", R_TextureStats_f, "print information about all loaded textures and some statistics");
+ Cvar_RegisterVariable (&gl_max_size);
+ Cvar_RegisterVariable (&gl_picmip);
+ Cvar_RegisterVariable (&gl_max_lightmapsize);
Cvar_RegisterVariable (&r_lerpimages);
- Cvar_RegisterVariable (&r_upload);
- Cvar_RegisterVariable (&r_precachetextures);
-#ifdef NORENDER
- r_upload.value = 0;
-#endif
-
- // 3dfx can only handle 256 wide textures
- if (!Q_strncasecmp ((char *)gl_renderer, "3dfx",4) || strstr((char *)gl_renderer, "Glide"))
- Cvar_Set ("r_max_size", "256");
-
- gltextures = qmalloc(sizeof(gltexture_t) * MAX_GLTEXTURES);
- memset(gltextures, 0, sizeof(gltexture_t) * MAX_GLTEXTURES);
- Cmd_AddCommand ("gl_texturemode", &Draw_TextureMode_f);
+ Cvar_RegisterVariable (&gl_texture_anisotropy);
+ Cvar_RegisterVariable (&gl_texturecompression);
+ Cvar_RegisterVariable (&gl_texturecompression_color);
+ Cvar_RegisterVariable (&gl_texturecompression_normal);
+ Cvar_RegisterVariable (&gl_texturecompression_gloss);
+ Cvar_RegisterVariable (&gl_texturecompression_glow);
+ Cvar_RegisterVariable (&gl_texturecompression_2d);
+ Cvar_RegisterVariable (&gl_texturecompression_q3bsplightmaps);
+ Cvar_RegisterVariable (&gl_texturecompression_q3bspdeluxemaps);
+ Cvar_RegisterVariable (&gl_texturecompression_sky);
+ Cvar_RegisterVariable (&gl_texturecompression_lightcubemaps);
+ Cvar_RegisterVariable (&gl_texturecompression_reflectmask);
+ Cvar_RegisterVariable (&gl_nopartialtextureupdates);
R_RegisterModule("R_Textures", r_textures_start, r_textures_shutdown, r_textures_newmap);
}
-/*
-================
-R_FindTexture
-================
-*/
-int R_FindTexture (char *identifier)
+void R_Textures_Frame (void)
{
- int i;
- gltexture_t *glt;
+ static int old_aniso = 0;
- for (i=0, glt=gltextures ; i<numgltextures ; i++, glt++)
+ // could do procedural texture animation here, if we keep track of which
+ // textures were accessed this frame...
+
+ // free the resize buffers
+ resizebuffersize = 0;
+ if (resizebuffer)
+ {
+ Mem_Free(resizebuffer);
+ resizebuffer = NULL;
+ }
+ if (colorconvertbuffer)
+ {
+ Mem_Free(colorconvertbuffer);
+ colorconvertbuffer = NULL;
+ }
+
+ if (old_aniso != gl_texture_anisotropy.integer)
{
- if (!strcmp (identifier, glt->identifier))
- return gltextures[i].texnum;
+ gltexture_t *glt;
+ gltexturepool_t *pool;
+ GLint oldbindtexnum;
+
+ old_aniso = bound(1, gl_texture_anisotropy.integer, (int)vid.max_anisotropy);
+
+ Cvar_SetValueQuick(&gl_texture_anisotropy, old_aniso);
+
+ CHECKGLERROR
+ GL_ActiveTexture(0);
+ for (pool = gltexturepoolchain;pool;pool = pool->next)
+ {
+ for (glt = pool->gltchain;glt;glt = glt->chain)
+ {
+ // only update already uploaded images
+ if (glt->texnum && (glt->flags & TEXF_MIPMAP) == TEXF_MIPMAP)
+ {
+ oldbindtexnum = R_Mesh_TexBound(0, gltexturetypeenums[glt->texturetype]);
+
+ 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
+ }
+ }
+ }
}
+}
- return -1;
+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");
+ }
}
-void R_ResampleTextureLerpLine (byte *in, byte *out, int inwidth, int outwidth)
+static void GL_SetupTextureParameters(int flags, textype_t textype, 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_CLAMP_TO_EDGE : GL_REPEAT;
+
+ CHECKGLERROR
+
+ if (vid.support.ext_texture_filter_anisotropic && (flags & TEXF_MIPMAP))
{
- xi = (int) f >> 16;
- if (xi != oldx)
- {
- in += (xi - oldx) * 4;
- oldx = xi;
- }
- if (xi < endx)
+ int aniso = bound(1, gl_texture_anisotropy.integer, (int)vid.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 (flags & TEXF_MIPMAP)
{
- 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]);
+ qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);CHECKGLERROR
}
- else // last pixel of the line has no pixel to lerp to
+ else
{
- *out++ = in[0];
- *out++ = in[1];
- *out++ = in[2];
- *out++ = in[3];
+ qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_NEAREST);CHECKGLERROR
}
+ qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, GL_NEAREST);CHECKGLERROR
}
-}
-
-/*
-================
-R_ResampleTexture
-================
-*/
-void R_ResampleTexture (void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight)
-{
- if (r_lerpimages.value)
+ else if (flags & TEXF_FORCELINEAR)
{
- 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 (flags & TEXF_MIPMAP)
{
- yi = f >> 16;
- if (yi < endy)
+ if (gl_filter_min == GL_NEAREST_MIPMAP_LINEAR || gl_filter_min == GL_LINEAR_MIPMAP_LINEAR)
{
- 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;
+ qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);CHECKGLERROR
}
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;
- }
- memcpy(out, row1, outwidth * 4);
+ qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);CHECKGLERROR
}
}
- qfree(row1);
- qfree(row2);
+ else
+ {
+ qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_LINEAR);CHECKGLERROR
+ }
+ qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, GL_LINEAR);CHECKGLERROR
}
else
{
- int i, j;
- unsigned frac, fracstep;
- // relies on int being 4 bytes
- int *inrow, *out;
- out = outdata;
+ if (flags & TEXF_MIPMAP)
+ {
+ qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, gl_filter_min);CHECKGLERROR
+ }
+ else
+ {
+ qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, gl_filter_mag);CHECKGLERROR
+ }
+ qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, gl_filter_mag);CHECKGLERROR
+ }
- fracstep = inwidth*0x10000/outwidth;
- for (i = 0;i < outheight;i++)
+ if (textype == TEXTYPE_SHADOWMAP)
+ {
+ if (vid.support.arb_shadow)
{
- inrow = (int *)indata + inwidth*(i*inheight/outheight);
- frac = fracstep >> 1;
- j = outwidth - 4;
- while (j >= 0)
- {
- 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 -= 4;
- }
- if (j & 2)
+ if (flags & TEXF_COMPARE)
{
- out[0] = inrow[frac >> 16];frac += fracstep;
- out[1] = inrow[frac >> 16];frac += fracstep;
- out += 2;
+ qglTexParameteri(textureenum, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB);CHECKGLERROR
}
- if (j & 1)
+ else
{
- out[0] = inrow[frac >> 16];frac += fracstep;
- out += 1;
+ qglTexParameteri(textureenum, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE);CHECKGLERROR
}
+ qglTexParameteri(textureenum, GL_TEXTURE_COMPARE_FUNC_ARB, GL_LEQUAL);CHECKGLERROR
}
+ qglTexParameteri(textureenum, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE);CHECKGLERROR
}
+
+ CHECKGLERROR
}
-// in can be the same as out
-void GL_MipReduce(byte *in, byte *out, int width, int height, int destwidth, int destheight)
+static void R_Upload(gltexture_t *glt, const unsigned char *data, int fragx, int fragy, int fragz, int fragwidth, int fragheight, int fragdepth)
{
- int x, y, width2, height2, nextrow;
- if (width > destwidth)
+ int i, mip, width, height, depth;
+ GLint oldbindtexnum;
+ const unsigned char *prevbuffer;
+ prevbuffer = data;
+
+ CHECKGLERROR
+
+ // we need to restore the texture binding after finishing the upload
+ GL_ActiveTexture(0);
+ oldbindtexnum = R_Mesh_TexBound(0, gltexturetypeenums[glt->texturetype]);
+ qglBindTexture(gltexturetypeenums[glt->texturetype], glt->texnum);CHECKGLERROR
+
+ // these are rounded up versions of the size to do better resampling
+ if (vid.support.arb_texture_non_power_of_two || glt->texturetype == GLTEXTURETYPE_RECTANGLE)
{
- if (height > destheight)
+ 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);
+ }
+
+ R_MakeResizeBufferBigger(width * height * depth * glt->sides * glt->bytesperpixel);
+ R_MakeResizeBufferBigger(fragwidth * fragheight * fragdepth * glt->sides * glt->bytesperpixel);
+
+ if (prevbuffer == NULL)
+ {
+ 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;
+ }
+
+ // upload the image - preferring to do only complete uploads (drivers do not really like partial updates)
+
+ if ((glt->flags & (TEXF_MIPMAP | TEXF_PICMIP)) == 0 && glt->inputwidth == glt->tilewidth && glt->inputheight == glt->tileheight && glt->inputdepth == glt->tiledepth && (fragx != 0 || fragy != 0 || fragwidth != glt->tilewidth || fragheight != glt->tileheight))
+ {
+ // update a portion of the image
+ switch(glt->texturetype)
+ {
+ case GLTEXTURETYPE_2D:
+ qglTexSubImage2D(GL_TEXTURE_2D, 0, fragx, fragy, fragwidth, fragheight, glt->glformat, glt->gltype, prevbuffer);CHECKGLERROR
+ break;
+ case GLTEXTURETYPE_3D:
+ qglTexSubImage3D(GL_TEXTURE_3D, 0, fragx, fragy, fragz, fragwidth, fragheight, fragdepth, glt->glformat, glt->gltype, prevbuffer);CHECKGLERROR
+ break;
+ default:
+ Host_Error("R_Upload: partial update of type other than 2D");
+ break;
+ }
+ }
+ else
+ {
+ 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");
+
+ // cubemaps contain multiple images and thus get processed a bit differently
+ if (glt->texturetype != GLTEXTURETYPE_CUBEMAP)
{
- // reduce both
- width2 = width >> 1;
- height2 = height >> 1;
- nextrow = width << 2;
- for (y = 0;y < height2;y++)
+ if (glt->inputwidth != width || glt->inputheight != height || glt->inputdepth != depth)
{
- 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
+ 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;
}
}
- else
+ mip = 0;
+ if (qglGetCompressedTexImageARB)
{
- // reduce width
- width2 = width >> 1;
- for (y = 0;y < height;y++)
+ 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_2D:
+ qglTexImage2D(GL_TEXTURE_2D, mip++, glt->glinternalformat, width, height, 0, glt->glformat, glt->gltype, 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_MipReduce32(prevbuffer, resizebuffer, &width, &height, &depth, 1, 1, 1);
+ prevbuffer = resizebuffer;
+ qglTexImage2D(GL_TEXTURE_2D, mip++, glt->glinternalformat, width, height, 0, glt->glformat, glt->gltype, prevbuffer);CHECKGLERROR
}
}
+ break;
+ case GLTEXTURETYPE_3D:
+ qglTexImage3D(GL_TEXTURE_3D, mip++, glt->glinternalformat, width, height, depth, 0, glt->glformat, glt->gltype, 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, glt->gltype, 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, glt->gltype, 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, glt->gltype, prevbuffer);CHECKGLERROR
+ }
+ }
+ }
+ break;
+ case GLTEXTURETYPE_RECTANGLE:
+ qglTexImage2D(GL_TEXTURE_RECTANGLE_ARB, mip++, glt->glinternalformat, width, height, 0, glt->glformat, glt->gltype, NULL);CHECKGLERROR
+ break;
}
+ GL_SetupTextureParameters(glt->flags, glt->textype->textype, glt->texturetype);
}
- else
+ qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR
+}
+
+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, size;
+ gltexture_t *glt;
+ gltexturepool_t *pool = (gltexturepool_t *)rtexturepool;
+ textypeinfo_t *texinfo, *texinfo2;
+
+ if (cls.state == ca_dedicated)
+ return NULL;
+
+ if (texturetype == GLTEXTURETYPE_RECTANGLE && !vid.support.arb_texture_rectangle)
{
- if (height > destheight)
+ Con_Printf ("R_LoadTexture: rectangle texture not supported by driver\n");
+ return NULL;
+ }
+ if (texturetype == GLTEXTURETYPE_CUBEMAP && !vid.support.arb_texture_cube_map)
+ {
+ Con_Printf ("R_LoadTexture: cubemap texture not supported by driver\n");
+ return NULL;
+ }
+ if (texturetype == GLTEXTURETYPE_3D && !vid.support.ext_texture_3d)
+ {
+ 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
+ switch(textype)
+ {
+ case TEXTYPE_PALETTE:
+ if (flags & TEXF_ALPHA)
{
- // reduce height
- height2 = height >> 1;
- nextrow = width << 2;
- for (y = 0;y < height2;y++)
+ flags &= ~TEXF_ALPHA;
+ if (data)
{
- for (x = 0;x < width;x++)
+ for (i = 0;i < size;i++)
{
- 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;
+ if (((unsigned char *)&palette[data[i]])[3] < 255)
+ {
+ flags |= TEXF_ALPHA;
+ break;
+ }
}
- in += nextrow; // skip a line
}
}
- else
- Sys_Error("GL_MipReduce: desired size already achieved\n");
+ break;
+ case TEXTYPE_RGBA:
+ case TEXTYPE_BGRA:
+ if (flags & TEXF_ALPHA)
+ {
+ flags &= ~TEXF_ALPHA;
+ if (data)
+ {
+ for (i = 3;i < size;i += 4)
+ {
+ if (data[i] < 255)
+ {
+ flags |= TEXF_ALPHA;
+ break;
+ }
+ }
+ }
+ }
+ break;
+ case TEXTYPE_SHADOWMAP:
+ break;
+ case TEXTYPE_DXT1:
+ break;
+ case TEXTYPE_DXT1A:
+ case TEXTYPE_DXT3:
+ case TEXTYPE_DXT5:
+ flags |= TEXF_ALPHA;
+ break;
+ case TEXTYPE_ALPHA:
+ flags |= TEXF_ALPHA;
+ break;
+ case TEXTYPE_COLORBUFFER:
+ flags |= TEXF_ALPHA;
+ break;
+ default:
+ Host_Error("R_LoadTexture: unknown texture type");
}
+
+ texinfo2 = R_GetTexTypeInfo(textype, flags);
+ if(size == width * height * depth * sides * texinfo->inputbytesperpixel)
+ texinfo = texinfo2;
+ else
+ Con_Printf ("R_LoadTexture: input size changed after alpha fallback\n");
+
+ glt = (gltexture_t *)Mem_ExpandableArray_AllocRecord(&texturearray);
+ 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;
+ glt->textype = texinfo;
+ glt->texturetype = texturetype;
+ glt->inputdatasize = size;
+ glt->palette = palette;
+ glt->glinternalformat = texinfo->glinternalformat;
+ glt->glformat = texinfo->glformat;
+ glt->gltype = texinfo->gltype;
+ glt->bytesperpixel = texinfo->internalbytesperpixel;
+ glt->sides = glt->texturetype == GLTEXTURETYPE_CUBEMAP ? 6 : 1;
+ glt->texnum = 0;
+ glt->dirty = false;
+ glt->gltexturetypeenum = gltexturetypeenums[glt->texturetype];
+ // init the dynamic texture attributes, too [11/22/2007 Black]
+ glt->updatecallback = NULL;
+ glt->updatacallback_data = NULL;
+
+ GL_Texture_CalcImageSize(glt->texturetype, glt->flags, glt->inputwidth, glt->inputheight, glt->inputdepth, &glt->tilewidth, &glt->tileheight, &glt->tiledepth);
+
+ // upload the texture
+ // data may be NULL (blank texture for dynamic rendering)
+ CHECKGLERROR
+ qglGenTextures(1, (GLuint *)&glt->texnum);CHECKGLERROR
+ R_Upload(glt, data, 0, 0, 0, glt->inputwidth, glt->inputheight, glt->inputdepth);
+ if ((glt->flags & TEXF_ALLOWUPDATES) && gl_nopartialtextureupdates.integer)
+ glt->bufferpixels = Mem_Alloc(texturemempool, glt->tilewidth*glt->tileheight*glt->tiledepth*glt->sides*glt->bytesperpixel);
+
+ // texture converting and uploading can take a while, so make sure we're sending keepalives
+ CL_KeepaliveMessage(false);
+
+ return (rtexture_t *)glt;
}
-void GL_Upload32(int glslot, byte *data, int width, int height, int flags)
+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)
{
- int mip, width2, height2, width3, height3, internalformat;
- byte *gammadata, *buffer;
+ return R_SetupTexture(rtexturepool, identifier, width, height, 1, 1, flags, textype, GLTEXTURETYPE_2D, data, palette);
+}
- if (!r_upload.value)
- return;
+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);
+}
- // 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;
+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);
+}
- // 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;
+rtexture_t *R_LoadTextureRectangle(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, const unsigned char *data, textype_t textype, int flags, const unsigned int *palette)
+{
+ return R_SetupTexture(rtexturepool, identifier, width, height, 1, 1, flags, textype, GLTEXTURETYPE_RECTANGLE, data, palette);
+}
- gammadata = qmalloc(width*height*4);
- buffer = qmalloc(width2*height2*4);
- if (!gammadata || !buffer)
- Host_Error("GL_Upload32: out of memory\n");
+static int R_ShadowMapTextureFlags(int precision, qboolean filter)
+{
+ int flags = TEXF_CLAMP;
+ if (filter)
+ flags |= TEXF_FORCELINEAR | TEXF_COMPARE;
+ else
+ flags |= TEXF_FORCENEAREST;
+ if (precision <= 16)
+ flags |= TEXF_LOWPRECISION;
+ return flags;
+}
- Image_CopyRGBAGamma(data, gammadata, width*height);
+rtexture_t *R_LoadTextureShadowMapRectangle(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, int precision, qboolean filter)
+{
+ return R_SetupTexture(rtexturepool, identifier, width, height, 1, 1, R_ShadowMapTextureFlags(precision, filter), TEXTYPE_SHADOWMAP, GLTEXTURETYPE_RECTANGLE, NULL, NULL);
+}
- R_ResampleTexture(gammadata, width, height, buffer, width2, height2);
+rtexture_t *R_LoadTextureShadowMap2D(rtexturepool_t *rtexturepool, const char *identifier, int width, int height, int precision, qboolean filter)
+{
+ return R_SetupTexture(rtexturepool, identifier, width, height, 1, 1, R_ShadowMapTextureFlags(precision, filter), TEXTYPE_SHADOWMAP, GLTEXTURETYPE_2D, NULL, NULL);
+}
- qfree(gammadata);
+rtexture_t *R_LoadTextureShadowMapCube(rtexturepool_t *rtexturepool, const char *identifier, int width, int precision, qboolean filter)
+{
+ return R_SetupTexture(rtexturepool, identifier, width, width, 1, 6, R_ShadowMapTextureFlags(precision, filter), TEXTYPE_SHADOWMAP, GLTEXTURETYPE_CUBEMAP, NULL, NULL);
+}
- while (width2 > width3 || height2 > height3)
+int R_SaveTextureDDSFile(rtexture_t *rt, const char *filename, qboolean skipuncompressed)
+{
+ gltexture_t *glt = (gltexture_t *)rt;
+ unsigned char *dds;
+ int oldbindtexnum;
+ int bytesperpixel = 0;
+ int bytesperblock = 0;
+ int dds_flags;
+ int dds_format_flags;
+ int dds_caps1;
+ int dds_caps2;
+ int ret;
+ int mip;
+ int mipmaps;
+ int mipinfo[16][4];
+ int ddssize = 128;
+ GLint internalformat;
+ const char *ddsfourcc;
+ if (!rt)
+ return -1; // NULL pointer
+ if (!strcmp(gl_version, "2.0.5885 WinXP Release"))
+ return -2; // broken driver - crashes on reading internal format
+ if (!qglGetTexLevelParameteriv)
+ return -2;
+ GL_ActiveTexture(0);
+ oldbindtexnum = R_Mesh_TexBound(0, gltexturetypeenums[glt->texturetype]);
+ qglBindTexture(gltexturetypeenums[glt->texturetype], glt->texnum);CHECKGLERROR
+ qglGetTexLevelParameteriv(gltexturetypeenums[glt->texturetype], 0, GL_TEXTURE_INTERNAL_FORMAT, &internalformat);
+ switch(internalformat)
{
- GL_MipReduce(buffer, buffer, width2, height2, width3, height3);
-
- if (width2 > width3)
- width2 >>= 1;
- if (height2 > height3)
- height2 >>= 1;
+ default: ddsfourcc = NULL;bytesperpixel = 4;break;
+ case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+ case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: ddsfourcc = "DXT1";bytesperblock = 8;break;
+ case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: ddsfourcc = "DXT3";bytesperblock = 16;break;
+ case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: ddsfourcc = "DXT5";bytesperblock = 16;break;
}
-
- 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 (!bytesperblock && skipuncompressed)
+ return -3; // skipped
+ memset(mipinfo, 0, sizeof(mipinfo));
+ mipinfo[0][0] = glt->tilewidth;
+ mipinfo[0][1] = glt->tileheight;
+ mipmaps = 1;
+ if (glt->flags & TEXF_MIPMAP)
{
- while (width2 > 1 || height2 > 1)
+ for (mip = 1;mip < 16;mip++)
{
- 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);
+ mipinfo[mip][0] = mipinfo[mip-1][0] > 1 ? mipinfo[mip-1][0] >> 1 : 1;
+ mipinfo[mip][1] = mipinfo[mip-1][1] > 1 ? mipinfo[mip-1][1] >> 1 : 1;
+ if (mipinfo[mip][0] == 1 && mipinfo[mip][1] == 1)
+ {
+ mip++;
+ break;
+ }
}
-
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
+ mipmaps = mip;
+ }
+ for (mip = 0;mip < mipmaps;mip++)
+ {
+ mipinfo[mip][2] = bytesperblock ? ((mipinfo[mip][0]+3)/4)*((mipinfo[mip][1]+3)/4)*bytesperblock : mipinfo[mip][0]*mipinfo[mip][1]*bytesperpixel;
+ mipinfo[mip][3] = ddssize;
+ ddssize += mipinfo[mip][2];
+ }
+ dds = Mem_Alloc(tempmempool, ddssize);
+ if (!dds)
+ return -4;
+ dds_caps1 = 0x1000; // DDSCAPS_TEXTURE
+ dds_caps2 = 0;
+ if (bytesperblock)
+ {
+ dds_flags = 0x81007; // DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_LINEARSIZE
+ dds_format_flags = 0x4; // DDPF_FOURCC
}
else
{
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max);
- glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
+ dds_flags = 0x100F; // DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PITCH
+ dds_format_flags = 0x41; // DDPF_RGB | DDPF_ALPHAPIXELS
}
- glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
-
- qfree(buffer);
+ if (mipmaps)
+ {
+ dds_flags |= 0x20000; // DDSD_MIPMAPCOUNT
+ dds_caps1 |= 0x400008; // DDSCAPS_MIPMAP | DDSCAPS_COMPLEX
+ }
+ memcpy(dds, "DDS ", 4);
+ StoreLittleLong(dds+4, ddssize);
+ StoreLittleLong(dds+8, dds_flags);
+ StoreLittleLong(dds+12, mipinfo[0][1]); // height
+ StoreLittleLong(dds+16, mipinfo[0][0]); // width
+ StoreLittleLong(dds+24, 1); // depth
+ StoreLittleLong(dds+28, mipmaps); // mipmaps
+ StoreLittleLong(dds+76, 32); // format size
+ StoreLittleLong(dds+80, dds_format_flags);
+ StoreLittleLong(dds+108, dds_caps1);
+ StoreLittleLong(dds+112, dds_caps2);
+ if (bytesperblock)
+ {
+ StoreLittleLong(dds+20, mipinfo[0][2]); // linear size
+ memcpy(dds+84, ddsfourcc, 4);
+ for (mip = 0;mip < mipmaps;mip++)
+ {
+ qglGetCompressedTexImageARB(gltexturetypeenums[glt->texturetype], mip, dds + mipinfo[mip][3]);CHECKGLERROR
+ }
+ }
+ else
+ {
+ StoreLittleLong(dds+20, mipinfo[0][0]*bytesperpixel); // pitch
+ StoreLittleLong(dds+88, bytesperpixel*8); // bits per pixel
+ dds[94] = dds[97] = dds[100] = dds[107] = 255; // bgra byte order masks
+ for (mip = 0;mip < mipmaps;mip++)
+ {
+ qglGetTexImage(gltexturetypeenums[glt->texturetype], mip, GL_BGRA, GL_UNSIGNED_BYTE, dds + mipinfo[mip][3]);CHECKGLERROR
+ }
+ }
+ qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR
+ ret = FS_WriteFile(filename, dds, ddssize);
+ Mem_Free(dds);
+ return ret ? ddssize : -5;
}
-void GL_Upload8 (int glslot, byte *data, int width, int height, int flags)
+rtexture_t *R_LoadTextureDDSFile(rtexturepool_t *rtexturepool, const char *filename, int flags, qboolean *hasalphaflag, float *avgcolor)
{
- byte *data32;
- data32 = qmalloc(width*height*4);
- Image_Copy8bitRGBA(data, data32, width*height, d_8to24table);
- GL_Upload32(glslot, data32, width, height, flags);
- qfree(data32);
-}
+ int i, size, dds_format_flags, dds_miplevels, dds_width, dds_height;
+ //int dds_flags;
+ textype_t textype;
+ int bytesperblock, bytesperpixel;
+ int mipcomplete;
+ gltexture_t *glt;
+ gltexturepool_t *pool = (gltexturepool_t *)rtexturepool;
+ textypeinfo_t *texinfo;
+ int mip, mipwidth, mipheight, mipsize;
+ unsigned int c;
+ GLint oldbindtexnum;
+ const unsigned char *mippixels, *ddspixels;
+ unsigned char *dds;
+ fs_offset_t ddsfilesize;
+ unsigned int ddssize;
+
+ if (cls.state == ca_dedicated)
+ return NULL;
-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)
- {
- size += width2 * height2;
- if (width2 > 1)
- width2 >>= 1;
- if (height2 > 1)
- height2 >>= 1;
- }
- size++; // count the last 1x1 mipmap
- }
- else
- size = width2*height2;
+ dds = FS_LoadFile(filename, tempmempool, true, &ddsfilesize);
+ ddssize = ddsfilesize;
- size *= 4; // RGBA
+ if (!dds)
+ {
+ Log_Printf("ddstexturefailures.log", "%s\n", filename);
+ return NULL; // not found
+ }
- return size;
-}
+ if (ddsfilesize <= 128 || memcmp(dds, "DDS ", 4) || ddssize < (unsigned int)BuffLittleLong(dds+4) || BuffLittleLong(dds+76) != 32)
+ {
+ Mem_Free(dds);
+ Con_Printf("^1%s: not a DDS image\n", filename);
+ return NULL;
+ }
-/*
-================
-GL_LoadTexture
-================
-*/
-rtexture_t *R_LoadTexture (char *identifier, int width, int height, byte *data, int flags)
-{
- int i, bytesperpixel, internalflags, precache;
- gltexture_t *glt;
- unsigned short crc;
+ //dds_flags = BuffLittleLong(dds+8);
+ dds_format_flags = BuffLittleLong(dds+80);
+ dds_miplevels = (BuffLittleLong(dds+108) & 0x400000) ? BuffLittleLong(dds+28) : 1;
+ dds_width = BuffLittleLong(dds+16);
+ dds_height = BuffLittleLong(dds+12);
+ ddspixels = dds + 128;
- if (isDedicated)
+ flags &= ~TEXF_ALPHA;
+ if ((dds_format_flags & 0x40) && BuffLittleLong(dds+88) == 32)
+ {
+ // very sloppy BGRA 32bit identification
+ textype = TEXTYPE_BGRA;
+ bytesperblock = 0;
+ bytesperpixel = 4;
+ size = INTOVERFLOW_MUL(INTOVERFLOW_MUL(dds_width, dds_height), bytesperpixel);
+ if(INTOVERFLOW_ADD(128, size) > INTOVERFLOW_NORMALIZE(ddsfilesize))
+ {
+ Mem_Free(dds);
+ Con_Printf("^1%s: invalid BGRA DDS image\n", filename);
+ return NULL;
+ }
+ // check alpha
+ for (i = 3;i < size;i += 4)
+ if (ddspixels[i] < 255)
+ break;
+ if (i >= size)
+ flags &= ~TEXF_ALPHA;
+ }
+ else if (!memcmp(dds+84, "DXT1", 4))
+ {
+ // we need to find out if this is DXT1 (opaque) or DXT1A (transparent)
+ // LordHavoc: it is my belief that this does not infringe on the
+ // patent because it is not decoding pixels...
+ textype = TEXTYPE_DXT1;
+ bytesperblock = 8;
+ bytesperpixel = 0;
+ //size = ((dds_width+3)/4)*((dds_height+3)/4)*bytesperblock;
+ size = INTOVERFLOW_MUL(INTOVERFLOW_MUL(INTOVERFLOW_DIV(INTOVERFLOW_ADD(dds_width, 3), 4), INTOVERFLOW_DIV(INTOVERFLOW_ADD(dds_height, 3), 4)), bytesperblock);
+ if(INTOVERFLOW_ADD(128, size) > INTOVERFLOW_NORMALIZE(ddsfilesize))
+ {
+ Mem_Free(dds);
+ Con_Printf("^1%s: invalid DXT1 DDS image\n", filename);
+ return NULL;
+ }
+ for (i = 0;i < size;i += bytesperblock)
+ if (ddspixels[i+0] + ddspixels[i+1] * 256 <= ddspixels[i+2] + ddspixels[i+3] * 256)
+ break;
+ if (i < size)
+ textype = TEXTYPE_DXT1A;
+ else
+ flags &= ~TEXF_ALPHA;
+ }
+ else if (!memcmp(dds+84, "DXT3", 4))
+ {
+ textype = TEXTYPE_DXT3;
+ bytesperblock = 16;
+ bytesperpixel = 0;
+ size = INTOVERFLOW_MUL(INTOVERFLOW_MUL(INTOVERFLOW_DIV(INTOVERFLOW_ADD(dds_width, 3), 4), INTOVERFLOW_DIV(INTOVERFLOW_ADD(dds_height, 3), 4)), bytesperblock);
+ if(INTOVERFLOW_ADD(128, size) > INTOVERFLOW_NORMALIZE(ddsfilesize))
+ {
+ Mem_Free(dds);
+ Con_Printf("^1%s: invalid DXT3 DDS image\n", filename);
+ return NULL;
+ }
+ }
+ else if (!memcmp(dds+84, "DXT5", 4))
+ {
+ textype = TEXTYPE_DXT5;
+ bytesperblock = 16;
+ bytesperpixel = 0;
+ size = INTOVERFLOW_MUL(INTOVERFLOW_MUL(INTOVERFLOW_DIV(INTOVERFLOW_ADD(dds_width, 3), 4), INTOVERFLOW_DIV(INTOVERFLOW_ADD(dds_height, 3), 4)), bytesperblock);
+ if(INTOVERFLOW_ADD(128, size) > INTOVERFLOW_NORMALIZE(ddsfilesize))
+ {
+ Mem_Free(dds);
+ Con_Printf("^1%s: invalid DXT5 DDS image\n", filename);
+ return NULL;
+ }
+ }
+ else
+ {
+ Mem_Free(dds);
+ Con_Printf("^1%s: unrecognized/unsupported DDS format\n", filename);
return NULL;
+ }
- if (!identifier[0])
- Host_Error("R_LoadTexture: no identifier\n");
- if (data == NULL)
- Host_Error("R_LoadTexture: \"%s\" has no data\n", identifier);
+ // return whether this texture is transparent
+ if (hasalphaflag)
+ *hasalphaflag = (flags & TEXF_ALPHA) != 0;
- // clear the alpha flag if the texture has no transparent pixels
- if (flags & TEXF_ALPHA)
+ // calculate average color if requested
+ if (avgcolor)
{
- int alpha = false;
- if (flags & TEXF_RGBA)
+ float f;
+ Vector4Clear(avgcolor);
+ if (bytesperblock)
{
- for (i = 0;i < width * height;i++)
+ for (i = bytesperblock == 16 ? 8 : 0;i < size;i += bytesperblock)
{
- if (data[i * 4 + 3] < 255)
- {
- alpha = true;
- break;
- }
+ c = ddspixels[i] + 256*ddspixels[i+1] + 65536*ddspixels[i+2] + 16777216*ddspixels[i+3];
+ avgcolor[0] += ((c >> 11) & 0x1F) + ((c >> 27) & 0x1F);
+ avgcolor[1] += ((c >> 5) & 0x3F) + ((c >> 21) & 0x3F);
+ avgcolor[2] += ((c ) & 0x1F) + ((c >> 16) & 0x1F);
}
+ f = (float)bytesperblock / size;
+ avgcolor[0] *= (0.5f / 31.0f) * f;
+ avgcolor[1] *= (0.5f / 63.0f) * f;
+ avgcolor[2] *= (0.5f / 31.0f) * f;
+ avgcolor[3] = 1; // too hard to calculate
}
else
{
- for (i = 0;i < width * height;i++)
+ for (i = 0;i < size;i += 4)
{
- if (data[i] == 255)
- {
- alpha = true;
- break;
- }
+ avgcolor[0] += ddspixels[i+2];
+ avgcolor[1] += ddspixels[i+1];
+ avgcolor[2] += ddspixels[i];
+ avgcolor[3] += ddspixels[i+3];
}
+ f = (1.0f / 255.0f) * bytesperpixel / size;
+ avgcolor[0] *= f;
+ avgcolor[1] *= f;
+ avgcolor[2] *= f;
+ avgcolor[3] *= f;
}
- if (!alpha)
- flags &= ~TEXF_ALPHA;
}
- if (flags & TEXF_RGBA)
- bytesperpixel = 4;
+ if (dds_miplevels > 1)
+ flags |= TEXF_MIPMAP;
else
- bytesperpixel = 1;
+ flags &= ~TEXF_MIPMAP;
- internalflags = 0;
- if (r_lerpimages.value != 0)
- internalflags |= GLTEXF_LERPED;
+ // if S3TC is not supported, there's very little we can do about it
+ if (bytesperblock && !vid.support.ext_texture_compression_s3tc)
+ {
+ Mem_Free(dds);
+ Con_Printf("^1%s: DDS file is compressed but OpenGL driver does not support S3TC\n", filename);
+ return NULL;
+ }
+
+ texinfo = R_GetTexTypeInfo(textype, flags);
- // 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 ; i<numgltextures ; i++, glt++)
+ glt = (gltexture_t *)Mem_ExpandableArray_AllocRecord(&texturearray);
+ strlcpy (glt->identifier, filename, sizeof(glt->identifier));
+ glt->pool = pool;
+ glt->chain = pool->gltchain;
+ pool->gltchain = glt;
+ glt->inputwidth = dds_width;
+ glt->inputheight = dds_height;
+ glt->inputdepth = 1;
+ glt->flags = flags;
+ glt->textype = texinfo;
+ glt->texturetype = GLTEXTURETYPE_2D;
+ glt->inputdatasize = ddssize;
+ glt->glinternalformat = texinfo->glinternalformat;
+ glt->glformat = texinfo->glformat;
+ glt->gltype = texinfo->gltype;
+ glt->bytesperpixel = texinfo->internalbytesperpixel;
+ glt->sides = 1;
+ glt->gltexturetypeenum = gltexturetypeenums[glt->texturetype];
+ glt->tilewidth = dds_width;
+ glt->tileheight = dds_height;
+ glt->tiledepth = 1;
+
+ // texture uploading can take a while, so make sure we're sending keepalives
+ CL_KeepaliveMessage(false);
+
+ // upload the texture
+ // we need to restore the texture binding after finishing the upload
+ CHECKGLERROR
+ GL_ActiveTexture(0);
+ oldbindtexnum = R_Mesh_TexBound(0, gltexturetypeenums[glt->texturetype]);
+ qglGenTextures(1, (GLuint *)&glt->texnum);CHECKGLERROR
+ qglBindTexture(gltexturetypeenums[glt->texturetype], glt->texnum);CHECKGLERROR
+ mippixels = ddspixels;
+ mipwidth = dds_width;
+ mipheight = dds_height;
+ mipcomplete = false;
+ for (mip = 0;mip < dds_miplevels+1;mip++)
{
- if (!strcmp (identifier, glt->identifier))
+ mipsize = bytesperblock ? ((mipwidth+3)/4)*((mipheight+3)/4)*bytesperblock : mipwidth*mipheight*bytesperpixel;
+ if (mippixels + mipsize > dds + ddssize)
+ break;
+ if (bytesperblock)
{
- // 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;
+ qglCompressedTexImage2DARB(GL_TEXTURE_2D, mip, glt->glinternalformat, mipwidth, mipheight, 0, mipsize, mippixels);CHECKGLERROR
}
+ else
+ {
+ qglTexImage2D(GL_TEXTURE_2D, mip, glt->glinternalformat, mipwidth, mipheight, 0, glt->glformat, glt->gltype, mippixels);CHECKGLERROR
+ }
+ mippixels += mipsize;
+ if (mipwidth <= 1 && mipheight <= 1)
+ {
+ mipcomplete = true;
+ break;
+ }
+ if (mipwidth > 1)
+ mipwidth >>= 1;
+ if (mipheight > 1)
+ mipheight >>= 1;
}
-
-/*
- if (freeglt)
+ if (dds_miplevels > 1 && !mipcomplete)
{
- glt = freeglt;
- strcpy (glt->identifier, identifier);
+ // need to set GL_TEXTURE_MAX_LEVEL
+ qglTexParameteri(gltexturetypeenums[glt->texturetype], GL_TEXTURE_MAX_LEVEL, dds_miplevels - 1);CHECKGLERROR
}
- 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;
+ GL_SetupTextureParameters(glt->flags, glt->textype->textype, glt->texturetype);
+ qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR
- if (glt->inputtexels)
- qfree(glt->inputtexels);
- glt->inputtexeldatasize = width*height*bytesperpixel;
- glt->inputtexels = qmalloc(glt->inputtexeldatasize);
+ Mem_Free(dds);
+ return (rtexture_t *)glt;
+}
- memcpy(glt->inputtexels, data, glt->inputtexeldatasize);
+int R_TextureWidth(rtexture_t *rt)
+{
+ return rt ? ((gltexture_t *)rt)->inputwidth : 0;
+}
- glt->texeldatasize = R_CalcTexelDataSize(width, height, flags & TEXF_MIPMAP);
+int R_TextureHeight(rtexture_t *rt)
+{
+ return rt ? ((gltexture_t *)rt)->inputheight : 0;
+}
- precache = false;
- if (flags & TEXF_ALWAYSPRECACHE)
- precache = true;
- else if (r_precachetextures.value >= 1)
+void R_UpdateTexture(rtexture_t *rt, const unsigned char *data, int x, int y, int width, int height)
+{
+ gltexture_t *glt = (gltexture_t *)rt;
+ if (data == NULL)
+ Host_Error("R_UpdateTexture: no data supplied");
+ if (glt == NULL)
+ Host_Error("R_UpdateTexture: no texture supplied");
+ if (!glt->texnum)
+ Host_Error("R_UpdateTexture: texture has not been uploaded yet");
+ // update part of the texture
+ if (glt->bufferpixels)
{
- if (flags & TEXF_PRECACHE)
- precache = true;
- if (r_precachetextures.value >= 2)
- precache = true;
+ int j;
+ int bpp = glt->bytesperpixel;
+ int inputskip = width*bpp;
+ int outputskip = glt->tilewidth*bpp;
+ const unsigned char *input = data;
+ unsigned char *output = glt->bufferpixels;
+ if (x < 0)
+ {
+ width += x;
+ input -= x*bpp;
+ x = 0;
+ }
+ if (y < 0)
+ {
+ height += y;
+ input -= y*inputskip;
+ y = 0;
+ }
+ if (width > glt->tilewidth - x)
+ width = glt->tilewidth - x;
+ if (height > glt->tileheight - y)
+ height = glt->tileheight - y;
+ if (width < 1 || height < 1)
+ return;
+ glt->dirty = true;
+ glt->buffermodified = true;
+ output += y*outputskip + x*bpp;
+ for (j = 0;j < height;j++, output += outputskip, input += inputskip)
+ memcpy(output, input, width*bpp);
}
+ else
+ R_Upload(glt, data, x, y, 0, width, height, 1);
+}
- if (precache)
- GL_UploadTexture(glt);
-
- return (rtexture_t *)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->buffermodified && glt->bufferpixels)
+ {
+ glt->buffermodified = false;
+ R_Upload(glt, glt->bufferpixels, 0, 0, 0, glt->tilewidth, glt->tileheight, glt->tiledepth);
+ }
+ glt->dirty = false;
+ return glt->texnum;
+ }
+ else
+ return 0;
}
-// 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 );
}
projects / xonotic / darkplaces.git / blobdiff