gl_textures.c File Reference

#include "quakedef.h"
#include "image.h"
#include "jpeg.h"
#include "image_png.h"

Include dependency graph for gl_textures.c:

Go to the source code of this file.

Data Structures
struct	glmode_t
struct	gltexture_t
struct	gltexturepool_t
struct	textypeinfo_t

Macros
#define	GLTEXF_DYNAMIC   0x00080000
#define	GLTEXF_IMPORTANTBITS   (0)
#define	TEXTUREPOOL_SENTINEL   0xC0DEDBAD

Enumerations
enum	gltexturetype_t { GLTEXTURETYPE_2D , GLTEXTURETYPE_3D , GLTEXTURETYPE_CUBEMAP , GLTEXTURETYPE_TOTAL }

Functions
static void	GL_SetupTextureParameters (int flags, textype_t textype, int texturetype)
static void	GL_Texture_CalcImageSize (int texturetype, int flags, int miplevel, int inwidth, int inheight, int indepth, int *outwidth, int *outheight, int *outdepth, int *outmiplevels)
static void	GL_TextureMode_f (cmd_state_t *cmd)
rtexturepool_t *	R_AllocTexturePool (void)
static int	R_CalcTexelDataSize (gltexture_t *glt)
void	R_ClearTexture (rtexture_t *rt)
void	R_FreeTexture (rtexture_t *rt)
void	R_FreeTexturePool (rtexturepool_t **rtexturepool)
static textypeinfo_t *	R_GetTexTypeInfo (textype_t textype, 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, int miplevel, const unsigned int *palette)
rtexture_t *	R_LoadTexture3D (rtexturepool_t *rtexturepool, const char *identifier, int width, int height, int depth, const unsigned char *data, textype_t textype, int flags, int miplevel, const unsigned int *palette)
rtexture_t *	R_LoadTextureCubeMap (rtexturepool_t *rtexturepool, const char *identifier, int width, const unsigned char *data, textype_t textype, int flags, int miplevel, const unsigned int *palette)
rtexture_t *	R_LoadTextureDDSFile (rtexturepool_t *rtexturepool, const char *filename, qbool srgb, int flags, qbool *hasalphaflag, float *avgcolor, int miplevel, qbool optionaltexture)
rtexture_t *	R_LoadTextureRenderBuffer (rtexturepool_t *rtexturepool, const char *identifier, int width, int height, textype_t textype)
rtexture_t *	R_LoadTextureShadowMap2D (rtexturepool_t *rtexturepool, const char *identifier, int width, int height, textype_t textype, qbool filter)
static void	R_MakeResizeBufferBigger (int size)
void	R_MakeTextureDynamic (rtexture_t *rt, updatecallback_t updatecallback, void *data)
void	R_MarkDirtyTexture (rtexture_t *rt)
int	R_PicmipForFlags (int flags)
void	R_PurgeTexture (rtexture_t *rt)
int	R_RealGetTexture (rtexture_t *rt)
int	R_SaveTextureDDSFile (rtexture_t *rt, const char *filename, qbool skipuncompressed, qbool hasalpha)
static rtexture_t *	R_SetupTexture (rtexturepool_t *rtexturepool, const char *identifier, int width, int height, int depth, int sides, int flags, int miplevel, textype_t textype, int texturetype, const unsigned char *data, const unsigned int *palette)
int	R_TextureFlags (rtexture_t *rt)
int	R_TextureHeight (rtexture_t *rt)
static void	r_textures_devicelost (void)
static void	r_textures_devicerestored (void)
void	R_Textures_Frame (void)
void	R_Textures_Init (void)
static void	r_textures_newmap (void)
static void	r_textures_shutdown (void)
static void	r_textures_start (void)
static void	R_TextureStats_f (cmd_state_t *cmd)
void	R_TextureStats_Print (qbool printeach, qbool printpool, qbool printtotal)
int	R_TextureWidth (rtexture_t *rt)
static void	R_UpdateDynamicTexture (gltexture_t *glt)
void	R_UpdateTexture (rtexture_t *rt, const unsigned char *data, int x, int y, int z, int width, int height, int depth, int combine)
static void	R_UploadFullTexture (gltexture_t *glt, const unsigned char *data)
static void	R_UploadPartialTexture (gltexture_t *glt, const unsigned char *data, int fragx, int fragy, int fragz, int fragwidth, int fragheight, int fragdepth)

Variables
static unsigned char *	colorconvertbuffer
static int	cubemapside [6]
qbool	gl_filter_force = false
int	gl_filter_mag = GL_LINEAR
int	gl_filter_min = GL_LINEAR_MIPMAP_LINEAR
cvar_t	gl_max_lightmapsize = {CF_CLIENT | CF_ARCHIVE, "gl_max_lightmapsize", "512", "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_max_size = {CF_CLIENT | CF_ARCHIVE, "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_picmip = {CF_CLIENT | CF_ARCHIVE, "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	gl_picmip_other = {CF_CLIENT | CF_ARCHIVE, "gl_picmip_other", "0", "extra picmip level for other textures (may be negative, which will then reduce gl_picmip for these)"}
cvar_t	gl_picmip_sprites = {CF_CLIENT | CF_ARCHIVE, "gl_picmip_sprites", "0", "extra picmip level for sprite textures (may be negative, which will then reduce gl_picmip for these)"}
cvar_t	gl_picmip_world = {CF_CLIENT | CF_ARCHIVE, "gl_picmip_world", "0", "extra picmip level for world textures (may be negative, which will then reduce gl_picmip for these)"}
cvar_t	gl_texture_anisotropy = {CF_CLIENT | CF_ARCHIVE, "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 = {CF_CLIENT | CF_ARCHIVE, "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_2d = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_2d", "0", "whether to compress 2d (hud/menu) textures other than the font"}
cvar_t	gl_texturecompression_color = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_color", "1", "whether to compress colormap (diffuse) textures"}
cvar_t	gl_texturecompression_gloss = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_gloss", "1", "whether to compress glossmap (specular) textures"}
cvar_t	gl_texturecompression_glow = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_glow", "1", "whether to compress glowmap (luma) textures"}
cvar_t	gl_texturecompression_lightcubemaps = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_lightcubemaps", "1", "whether to compress light cubemaps (spotlights and other light projection images)"}
cvar_t	gl_texturecompression_normal = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_normal", "0", "whether to compress normalmap (normalmap) textures"}
cvar_t	gl_texturecompression_q3bspdeluxemaps = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_q3bspdeluxemaps", "0", "whether to compress deluxemaps in q3bsp format levels (only levels compiled with q3map2 -deluxe have these)"}
cvar_t	gl_texturecompression_q3bsplightmaps = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_q3bsplightmaps", "0", "whether to compress lightmaps in q3bsp format levels"}
cvar_t	gl_texturecompression_reflectmask = {CF_CLIENT | CF_ARCHIVE, "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_texturecompression_sky = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_sky", "0", "whether to compress sky textures"}
cvar_t	gl_texturecompression_sprites = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_sprites", "1", "whether to compress sprites"}
static gltexturepool_t *	gltexturepoolchain = NULL
static int	gltexturetypedimensions [GLTEXTURETYPE_TOTAL] = {2, 3, 2}
static int	gltexturetypeenums [GLTEXTURETYPE_TOTAL] = {GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP}
static glmode_t	modes [6]
cvar_t	r_lerpimages = {CF_CLIENT | CF_ARCHIVE, "r_lerpimages", "1", "bilinear filters images when scaling them up to power of 2 size (mode 1), looks better than glquake (mode 0)"}
cvar_t	r_picmipsprites = {CF_CLIENT | CF_ARCHIVE, "r_picmipsprites", "1", "make gl_picmip affect sprites too (saves some graphics memory in sprite heavy games) (setting this to 0 is a shorthand for gl_picmip_sprites -9999999)"}
cvar_t	r_picmipworld = {CF_CLIENT | CF_ARCHIVE, "r_picmipworld", "1", "whether gl_picmip shall apply to world textures too (setting this to 0 is a shorthand for gl_picmip_world -9999999)"}
cvar_t	r_texture_dds_load_alphamode = {CF_CLIENT, "r_texture_dds_load_alphamode", "1", "0: trust DDPF_ALPHAPIXELS flag, 1: texture format and brute force search if ambiguous, 2: texture format only"}
cvar_t	r_texture_dds_load_logfailure = {CF_CLIENT, "r_texture_dds_load_logfailure", "0", "log missing DDS textures to ddstexturefailures.log, 0: done log, 1: log with no optional textures (_norm, glow etc.). 2: log all"}
cvar_t	r_texture_dds_swdecode = {CF_CLIENT, "r_texture_dds_swdecode", "0", "0: don't software decode DDS, 1: software decode DDS if unsupported, 2: always software decode DDS"}
static unsigned char *	resizebuffer = NULL
static int	resizebuffersize = 0
static memexpandablearray_t	texturearray
static const unsigned char *	texturebuffer
static mempool_t *	texturemempool
static textypeinfo_t	textype_alpha = {"alpha", TEXTYPE_ALPHA , 1, 4, 4.0f, GL_ALPHA , GL_ALPHA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_bgra = {"bgra", TEXTYPE_BGRA , 4, 4, 4.0f, GL_RGB , GL_BGRA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_bgra_alpha = {"bgra_alpha", TEXTYPE_BGRA , 4, 4, 4.0f, GL_RGBA , GL_BGRA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_bgra_alpha_compress = {"bgra_alpha_compress", TEXTYPE_BGRA , 4, 4, 1.0f, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT , GL_BGRA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_bgra_compress = {"bgra_compress", TEXTYPE_BGRA , 4, 4, 0.5f, GL_COMPRESSED_RGB_S3TC_DXT1_EXT , GL_BGRA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_colorbuffer = {"colorbuffer", TEXTYPE_COLORBUFFER , 4, 4, 4.0f, GL_RGBA , GL_BGRA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_colorbuffer16f = {"colorbuffer16f", TEXTYPE_COLORBUFFER16F , 8, 8, 8.0f, GL_RGBA16F , GL_RGBA , GL_HALF_FLOAT }
static textypeinfo_t	textype_colorbuffer32f = {"colorbuffer32f", TEXTYPE_COLORBUFFER32F , 16, 16, 16.0f, GL_RGBA32F , GL_RGBA , GL_FLOAT }
static textypeinfo_t	textype_depth16 = {"depth16", TEXTYPE_DEPTHBUFFER16 , 2, 2, 2.0f, GL_DEPTH_COMPONENT16 , GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT}
static textypeinfo_t	textype_depth24 = {"depth24", TEXTYPE_DEPTHBUFFER24 , 4, 4, 4.0f, GL_DEPTH_COMPONENT24 , GL_DEPTH_COMPONENT, GL_UNSIGNED_INT }
static textypeinfo_t	textype_depth24stencil8 = {"depth24stencil8", TEXTYPE_DEPTHBUFFER24STENCIL8, 4, 4, 4.0f, GL_DEPTH24_STENCIL8 , GL_DEPTH_STENCIL , GL_UNSIGNED_INT_24_8}
static textypeinfo_t	textype_dxt1 = {"dxt1", TEXTYPE_DXT1 , 4, 0, 0.5f, GL_COMPRESSED_RGB_S3TC_DXT1_EXT , 0 , 0 }
static textypeinfo_t	textype_dxt1a = {"dxt1a", TEXTYPE_DXT1A , 4, 0, 0.5f, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT , 0 , 0 }
static textypeinfo_t	textype_dxt3 = {"dxt3", TEXTYPE_DXT3 , 4, 0, 1.0f, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT , 0 , 0 }
static textypeinfo_t	textype_dxt5 = {"dxt5", TEXTYPE_DXT5 , 4, 0, 1.0f, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT , 0 , 0 }
static textypeinfo_t	textype_palette = {"palette", TEXTYPE_PALETTE , 1, 4, 4.0f, GL_RGB , GL_BGRA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_palette_alpha = {"palette_alpha", TEXTYPE_PALETTE , 1, 4, 4.0f, GL_RGBA , GL_BGRA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_rgba = {"rgba", TEXTYPE_RGBA , 4, 4, 4.0f, GL_RGB , GL_RGBA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_rgba_alpha = {"rgba_alpha", TEXTYPE_RGBA , 4, 4, 4.0f, GL_RGBA , GL_RGBA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_rgba_alpha_compress = {"rgba_alpha_compress", TEXTYPE_RGBA , 4, 4, 1.0f, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT , GL_RGBA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_rgba_compress = {"rgba_compress", TEXTYPE_RGBA , 4, 4, 0.5f, GL_COMPRESSED_RGB_S3TC_DXT1_EXT , GL_RGBA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_shadowmap16_comp = {"shadowmap16_comp", TEXTYPE_SHADOWMAP16_COMP , 2, 2, 2.0f, GL_DEPTH_COMPONENT16 , GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT}
static textypeinfo_t	textype_shadowmap16_raw = {"shadowmap16_raw", TEXTYPE_SHADOWMAP16_RAW , 2, 2, 2.0f, GL_DEPTH_COMPONENT16 , GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT}
static textypeinfo_t	textype_shadowmap24_comp = {"shadowmap24_comp", TEXTYPE_SHADOWMAP24_COMP , 4, 4, 4.0f, GL_DEPTH_COMPONENT24 , GL_DEPTH_COMPONENT, GL_UNSIGNED_INT }
static textypeinfo_t	textype_shadowmap24_raw = {"shadowmap24_raw", TEXTYPE_SHADOWMAP24_RAW , 4, 4, 4.0f, GL_DEPTH_COMPONENT24 , GL_DEPTH_COMPONENT, GL_UNSIGNED_INT }
static textypeinfo_t	textype_sRGB_bgra = {"sRGB_bgra", TEXTYPE_BGRA , 4, 4, 4.0f, GL_SRGB , GL_BGRA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_sRGB_bgra_alpha = {"sRGB_bgra_alpha", TEXTYPE_BGRA , 4, 4, 4.0f, GL_SRGB_ALPHA , GL_BGRA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_sRGB_bgra_alpha_compress = {"sRGB_bgra_alpha_compress", TEXTYPE_BGRA , 4, 4, 1.0f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_BGRA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_sRGB_bgra_compress = {"sRGB_bgra_compress", TEXTYPE_BGRA , 4, 4, 0.5f, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT , GL_BGRA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_sRGB_dxt1 = {"sRGB_dxt1", TEXTYPE_DXT1 , 4, 0, 0.5f, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT , 0 , 0 }
static textypeinfo_t	textype_sRGB_dxt1a = {"sRGB_dxt1a", TEXTYPE_DXT1A , 4, 0, 0.5f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0 , 0 }
static textypeinfo_t	textype_sRGB_dxt3 = {"sRGB_dxt3", TEXTYPE_DXT3 , 4, 0, 1.0f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0 , 0 }
static textypeinfo_t	textype_sRGB_dxt5 = {"sRGB_dxt5", TEXTYPE_DXT5 , 4, 0, 1.0f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0 , 0 }
static textypeinfo_t	textype_sRGB_palette = {"sRGB_palette", TEXTYPE_PALETTE , 1, 4, 4.0f, GL_SRGB , GL_BGRA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_sRGB_palette_alpha = {"sRGB_palette_alpha", TEXTYPE_PALETTE , 1, 4, 4.0f, GL_SRGB_ALPHA , GL_BGRA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_sRGB_rgba = {"sRGB_rgba", TEXTYPE_RGBA , 4, 4, 4.0f, GL_SRGB , GL_RGBA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_sRGB_rgba_alpha = {"sRGB_rgba_alpha", TEXTYPE_RGBA , 4, 4, 4.0f, GL_SRGB_ALPHA , GL_RGBA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_sRGB_rgba_alpha_compress = {"sRGB_rgba_alpha_compress", TEXTYPE_RGBA , 4, 4, 1.0f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_RGBA , GL_UNSIGNED_BYTE }
static textypeinfo_t	textype_sRGB_rgba_compress = {"sRGB_rgba_compress", TEXTYPE_RGBA , 4, 4, 0.5f, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT , GL_RGBA , GL_UNSIGNED_BYTE }

Macro Definition Documentation

GLTEXF_DYNAMIC

#define GLTEXF_DYNAMIC   0x00080000

Definition at line 65 of file gl_textures.c.

Referenced by R_MakeTextureDynamic(), R_MarkDirtyTexture(), and R_RealGetTexture().

GLTEXF_IMPORTANTBITS

#define GLTEXF_IMPORTANTBITS   (0)

Definition at line 63 of file gl_textures.c.

TEXTUREPOOL_SENTINEL

#define TEXTUREPOOL_SENTINEL   0xC0DEDBAD

Definition at line 239 of file gl_textures.c.

Referenced by R_AllocTexturePool(), and R_FreeTexturePool().

Enumeration Type Documentation

gltexturetype_t

enum gltexturetype_t

Enumerator
GLTEXTURETYPE_2D
GLTEXTURETYPE_3D
GLTEXTURETYPE_CUBEMAP
GLTEXTURETYPE_TOTAL

Definition at line 155 of file gl_textures.c.

{
    GLTEXTURETYPE_2D,
    GLTEXTURETYPE_3D,
    GLTEXTURETYPE_CUBEMAP,
    GLTEXTURETYPE_TOTAL
}

Function Documentation

GL_SetupTextureParameters()

static void GL_SetupTextureParameters ( int flags, textype_t textype, int texturetype )

static

Definition at line 837 of file gl_textures.c.

{
    int textureenum = gltexturetypeenums[texturetype];
    int wrapmode = (flags & TEXF_CLAMP) ? GL_CLAMP_TO_EDGE : GL_REPEAT;
 
    CHECKGLERROR
 
#ifdef GL_TEXTURE_MAX_ANISOTROPY_EXT
    if (vid.support.ext_texture_filter_anisotropic && (flags & TEXF_MIPMAP))
    {
        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
    }
#endif
    qglTexParameteri(textureenum, GL_TEXTURE_WRAP_S, wrapmode);CHECKGLERROR
    qglTexParameteri(textureenum, GL_TEXTURE_WRAP_T, wrapmode);CHECKGLERROR
#ifdef GL_TEXTURE_WRAP_R
    if (gltexturetypedimensions[texturetype] >= 3)
    {
        qglTexParameteri(textureenum, GL_TEXTURE_WRAP_R, wrapmode);CHECKGLERROR
    }
#endif
 
    CHECKGLERROR
    if (!gl_filter_force && flags & TEXF_FORCENEAREST)
    {
        if (flags & TEXF_MIPMAP)
        {
            qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);CHECKGLERROR
        }
        else
        {
            qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_NEAREST);CHECKGLERROR
        }
        qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, GL_NEAREST);CHECKGLERROR
    }
    else if (!gl_filter_force && flags & TEXF_FORCELINEAR)
    {
        if (flags & TEXF_MIPMAP)
        {
            if (gl_filter_min == GL_NEAREST_MIPMAP_LINEAR || gl_filter_min == GL_LINEAR_MIPMAP_LINEAR)
            {
                qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);CHECKGLERROR
            }
            else
            {
                qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);CHECKGLERROR
            }
        }
        else
        {
            qglTexParameteri(textureenum, GL_TEXTURE_MIN_FILTER, GL_LINEAR);CHECKGLERROR
        }
        qglTexParameteri(textureenum, GL_TEXTURE_MAG_FILTER, GL_LINEAR);CHECKGLERROR
    }
    else
    {
        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
    }
 
#ifndef USE_GLES2
    switch(textype)
    {
    case TEXTYPE_SHADOWMAP16_COMP:
    case TEXTYPE_SHADOWMAP24_COMP:
        qglTexParameteri(textureenum, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);CHECKGLERROR
        qglTexParameteri(textureenum, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);CHECKGLERROR
        break;
    case TEXTYPE_SHADOWMAP16_RAW:
    case TEXTYPE_SHADOWMAP24_RAW:
        qglTexParameteri(textureenum, GL_TEXTURE_COMPARE_MODE, GL_NONE);CHECKGLERROR
        qglTexParameteri(textureenum, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);CHECKGLERROR
        break;
    default:
        break;
    }
#endif
 
    CHECKGLERROR
}

References bound, CHECKGLERROR, Cvar_SetValueQuick(), viddef_support_t::ext_texture_filter_anisotropic, flags, GL_CLAMP_TO_EDGE, GL_COMPARE_R_TO_TEXTURE, gl_filter_force, gl_filter_mag, gl_filter_min, GL_LEQUAL, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_NEAREST, GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST_MIPMAP_NEAREST, GL_NONE, GL_REPEAT, gl_texture_anisotropy, GL_TEXTURE_COMPARE_FUNC, GL_TEXTURE_COMPARE_MODE, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MAX_ANISOTROPY_EXT, GL_TEXTURE_MIN_FILTER, GL_TEXTURE_WRAP_R, GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, gltexturetypedimensions, gltexturetypeenums, cvar_t::integer, viddef_t::max_anisotropy, viddef_t::support, TEXF_CLAMP, TEXF_FORCELINEAR, TEXF_FORCENEAREST, TEXF_MIPMAP, TEXTYPE_SHADOWMAP16_COMP, TEXTYPE_SHADOWMAP16_RAW, TEXTYPE_SHADOWMAP24_COMP, TEXTYPE_SHADOWMAP24_RAW, and vid.

Referenced by R_LoadTextureDDSFile(), and R_UploadFullTexture().

GL_Texture_CalcImageSize()

static void GL_Texture_CalcImageSize ( int texturetype, int flags, int miplevel, int inwidth, int inheight, int indepth, int * outwidth, int * outheight, int * outdepth, int * outmiplevels )

static

Definition at line 511 of file gl_textures.c.

{
    int picmip = 0, maxsize = 0, width2 = 1, height2 = 1, depth2 = 1, miplevels = 1;
 
    switch (texturetype)
    {
    default:
    case GLTEXTURETYPE_2D:
        maxsize = vid.maxtexturesize_2d;
        if (flags & TEXF_PICMIP)
        {
            maxsize = bound(1, gl_max_size.integer, maxsize);
            picmip = miplevel;
        }
        break;
    case GLTEXTURETYPE_3D:
        maxsize = vid.maxtexturesize_3d;
        break;
    case GLTEXTURETYPE_CUBEMAP:
        maxsize = vid.maxtexturesize_cubemap;
        break;
    }
 
    width2 = min(inwidth >> picmip, maxsize);
    height2 = min(inheight >> picmip, maxsize);
    depth2 = min(indepth >> picmip, maxsize);
 
    miplevels = 1;
    if (flags & TEXF_MIPMAP)
    {
        int extent = max(width2, max(height2, depth2));
        while(extent >>= 1)
            miplevels++;
    }
 
    if (outwidth)
        *outwidth = max(1, width2);
    if (outheight)
        *outheight = max(1, height2);
    if (outdepth)
        *outdepth = max(1, depth2);
    if (outmiplevels)
        *outmiplevels = miplevels;
}

References bound, flags, gl_max_size, GLTEXTURETYPE_2D, GLTEXTURETYPE_3D, GLTEXTURETYPE_CUBEMAP, cvar_t::integer, max, viddef_t::maxtexturesize_2d, viddef_t::maxtexturesize_3d, viddef_t::maxtexturesize_cubemap, min, TEXF_MIPMAP, TEXF_PICMIP, and vid.

Referenced by R_CalcTexelDataSize(), R_LoadTextureRenderBuffer(), and R_SetupTexture().

GL_TextureMode_f()

static void GL_TextureMode_f ( cmd_state_t * cmd )

static

Definition at line 442 of file gl_textures.c.

{
    int i;
    GLint oldbindtexnum;
    gltexture_t *glt;
    gltexturepool_t *pool;
 
    if (Cmd_Argc(cmd) == 1)
    {
        Con_Printf("Texture mode is %sforced\n", gl_filter_force ? "" : "not ");
        for (i = 0;i < 6;i++)
        {
            if (gl_filter_min == modes[i].minification)
            {
                Con_Printf("%s\n", modes[i].name);
                return;
            }
        }
        Con_Print("current filter is unknown???\n");
        return;
    }
 
    for (i = 0;i < (int)(sizeof(modes)/sizeof(*modes));i++)
        if (!strcasecmp (modes[i].name, Cmd_Argv(cmd, 1) ) )
            break;
    if (i == 6)
    {
        Con_Print("bad filter name\n");
        return;
    }
 
    gl_filter_min = modes[i].minification;
    gl_filter_mag = modes[i].magnification;
    gl_filter_force = ((Cmd_Argc(cmd) > 2) && !strcasecmp(Cmd_Argv(cmd, 2), "force"));
 
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        // change all the existing mipmap texture objects
        // FIXME: force renderer(/client/something?) restart instead?
        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 && (gl_filter_force || !(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
                }
            }
        }
        break;
    }
}

References gltexture_t::chain, CHECKGLERROR, cmd(), Cmd_Argc(), Cmd_Argv(), Con_Print(), Con_Printf(), gltexture_t::flags, GL_ActiveTexture(), gl_filter_force, gl_filter_mag, gl_filter_min, GL_TEXTURE_MAG_FILTER, GL_TEXTURE_MIN_FILTER, gltexturepool_t::gltchain, gltexturepoolchain, gltexturetypeenums, i, int(), glmode_t::magnification, glmode_t::minification, modes, name, gltexturepool_t::next, R_Mesh_TexBound(), viddef_t::renderpath, RENDERPATH_GL32, RENDERPATH_GLES2, TEXF_FORCELINEAR, TEXF_FORCENEAREST, TEXF_MIPMAP, gltexture_t::texnum, gltexture_t::texturetype, and vid.

Referenced by R_Textures_Init().

R_AllocTexturePool()

rtexturepool_t * R_AllocTexturePool

(

void

)

Definition at line 389 of file gl_textures.c.

{
    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;
}

References gltexturepoolchain, Mem_Alloc, gltexturepool_t::next, NULL, gltexturepool_t::sentinel, texturemempool, and TEXTUREPOOL_SENTINEL.

Referenced by cl_video_start(), gl_draw_start(), gl_main_start(), Mod_GenerateLightmaps_CreateLightmaps(), Mod_Mesh_Create(), Mod_Q1BSP_LoadFaces(), Mod_Q1BSP_LoadSplitSky(), Mod_Q3BSP_Load(), Mod_VBSP_Load(), Mod_VBSP_LoadFaces(), r_explosion_start(), r_part_start(), R_Shadow_MakeTextures(), and r_sky_start().

R_CalcTexelDataSize()

static int R_CalcTexelDataSize ( gltexture_t * glt )

static

Definition at line 557 of file gl_textures.c.

{
    int width2, height2, depth2, size;
 
    GL_Texture_CalcImageSize(glt->texturetype, glt->flags, glt->miplevel, glt->inputwidth, glt->inputheight, glt->inputdepth, &width2, &height2, &depth2, NULL);
 
    size = width2 * height2 * depth2;
 
    if (glt->flags & TEXF_MIPMAP)
    {
        while (width2 > 1 || height2 > 1 || depth2 > 1)
        {
            if (width2 > 1)
                width2 >>= 1;
            if (height2 > 1)
                height2 >>= 1;
            if (depth2 > 1)
                depth2 >>= 1;
            size += width2 * height2 * depth2;
        }
    }
 
    return (int)(size * glt->textype->glinternalbytesperpixel) * glt->sides;
}

References gltexture_t::flags, GL_Texture_CalcImageSize(), textypeinfo_t::glinternalbytesperpixel, gltexture_t::inputdepth, gltexture_t::inputheight, gltexture_t::inputwidth, gltexture_t::miplevel, NULL, gltexture_t::sides, size, TEXF_MIPMAP, gltexture_t::texturetype, and gltexture_t::textype.

Referenced by R_TextureStats_Print().

R_ClearTexture()

void R_ClearTexture

(

rtexture_t *

rt

)

Definition at line 2387 of file gl_textures.c.

{
    gltexture_t *glt = (gltexture_t *)rt;
 
    R_UploadFullTexture(glt, NULL);
}

References NULL, and R_UploadFullTexture().

R_FreeTexture()

void R_FreeTexture

(

rtexture_t *

rt

)

Definition at line 351 of file gl_textures.c.

{
    gltexture_t *glt, **gltpointer;
 
    glt = (gltexture_t *)rt;
    if (glt == NULL)
        Host_Error("R_FreeTexture: texture == NULL");
 
    for (gltpointer = &glt->pool->gltchain;*gltpointer && *gltpointer != glt;gltpointer = &(*gltpointer)->chain);
    if (*gltpointer == glt)
        *gltpointer = glt->chain;
    else
        Host_Error("R_FreeTexture: texture \"%s\" not linked in pool", glt->identifier);
 
    R_Mesh_ClearBindingsForTexture(glt->texnum);
 
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        if (glt->texnum)
        {
            CHECKGLERROR
            qglDeleteTextures(1, (GLuint *)&glt->texnum);CHECKGLERROR
        }
        if (glt->renderbuffernum)
        {
            CHECKGLERROR
            qglDeleteRenderbuffers(1, (GLuint *)&glt->renderbuffernum);CHECKGLERROR
        }
        break;
    }
 
    if (glt->inputtexels)
        Mem_Free(glt->inputtexels);
    Mem_ExpandableArray_FreeRecord(&texturearray, glt);
}

References gltexture_t::chain, CHECKGLERROR, Host_Error(), gltexture_t::identifier, gltexture_t::inputtexels, Mem_ExpandableArray_FreeRecord(), Mem_Free, NULL, gltexture_t::pool, R_Mesh_ClearBindingsForTexture(), gltexture_t::renderbuffernum, viddef_t::renderpath, RENDERPATH_GL32, RENDERPATH_GLES2, gltexture_t::texnum, texturearray, and vid.

Referenced by Mod_GenerateLightmaps_DestroyLightmaps(), R_Bloom_StartFrame(), R_BuildFogHeightTexture(), R_FreeTexturePool(), R_PurgeTexture(), R_RenderTarget_FreeUnused(), R_Shadow_BounceGrid_ConvertPixelsAndUpload(), R_Shadow_BounceGrid_UpdateSpacing(), R_Shadow_FreeDeferred(), R_Shadow_FreeShadowMaps(), r_shadow_newmap(), R_Shadow_UpdateBounceGridTexture(), and SCR_ClearLoadingScreenTexture().

R_FreeTexturePool()

void R_FreeTexturePool

(

rtexturepool_t **

rtexturepool

)

Definition at line 403 of file gl_textures.c.

{
    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);
}

References gltexturepool_t::gltchain, gltexturepoolchain, Host_Error(), Mem_Free, gltexturepool_t::next, NULL, R_FreeTexture(), gltexturepool_t::sentinel, and TEXTUREPOOL_SENTINEL.

Referenced by cl_video_shutdown(), gl_draw_shutdown(), gl_main_shutdown(), Mod_UnloadModel(), r_explosion_shutdown(), r_part_shutdown(), R_Shadow_MakeTextures(), r_shadow_shutdown(), r_sky_shutdown(), and r_textures_shutdown().

R_GetTexTypeInfo()

static textypeinfo_t * R_GetTexTypeInfo ( textype_t textype, int flags )

static

Definition at line 255 of file gl_textures.c.

{
    switch(textype)
    {
#ifdef USE_GLES2
    case TEXTYPE_PALETTE: return (flags & TEXF_ALPHA) ? &textype_palette_alpha : &textype_palette;
    case TEXTYPE_RGBA: return ((flags & TEXF_ALPHA) ? &textype_rgba_alpha : &textype_rgba);
    case TEXTYPE_BGRA: return ((flags & TEXF_ALPHA) ? &textype_bgra_alpha : &textype_bgra);
#ifdef __ANDROID__
    case TEXTYPE_ETC1: return &textype_etc1;
#endif
    case TEXTYPE_ALPHA: return &textype_alpha;
    case TEXTYPE_COLORBUFFER: return &textype_colorbuffer;
    case TEXTYPE_COLORBUFFER16F: return &textype_colorbuffer16f;
    case TEXTYPE_COLORBUFFER32F: return &textype_colorbuffer32f;
    case TEXTYPE_DEPTHBUFFER16: return &textype_depth16;
    case TEXTYPE_DEPTHBUFFER24: return &textype_depth24;
    case TEXTYPE_DEPTHBUFFER24STENCIL8: return &textype_depth24stencil8;
    case TEXTYPE_SHADOWMAP16_COMP: return &textype_shadowmap16_comp;
    case TEXTYPE_SHADOWMAP16_RAW: return &textype_shadowmap16_raw;
    case TEXTYPE_SHADOWMAP24_COMP: return &textype_shadowmap24_comp;
    case TEXTYPE_SHADOWMAP24_RAW: return &textype_shadowmap24_raw;
#else
    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: return ((flags & TEXF_COMPRESS) && vid.support.ext_texture_compression_s3tc) ? ((flags & TEXF_ALPHA) ? &textype_rgba_alpha_compress : &textype_rgba_compress) : ((flags & TEXF_ALPHA) ? &textype_rgba_alpha : &textype_rgba);
    case TEXTYPE_BGRA: return ((flags & TEXF_COMPRESS) && vid.support.ext_texture_compression_s3tc) ? ((flags & TEXF_ALPHA) ? &textype_bgra_alpha_compress : &textype_bgra_compress) : ((flags & TEXF_ALPHA) ? &textype_bgra_alpha : &textype_bgra);
    case TEXTYPE_ALPHA: return &textype_alpha;
    case TEXTYPE_COLORBUFFER: return &textype_colorbuffer;
    case TEXTYPE_COLORBUFFER16F: return &textype_colorbuffer16f;
    case TEXTYPE_COLORBUFFER32F: return &textype_colorbuffer32f;
    case TEXTYPE_DEPTHBUFFER16: return &textype_depth16;
    case TEXTYPE_DEPTHBUFFER24: return &textype_depth24;
    case TEXTYPE_DEPTHBUFFER24STENCIL8: return &textype_depth24stencil8;
    case TEXTYPE_SHADOWMAP16_COMP: return &textype_shadowmap16_comp;
    case TEXTYPE_SHADOWMAP16_RAW: return &textype_shadowmap16_raw;
    case TEXTYPE_SHADOWMAP24_COMP: return &textype_shadowmap24_comp;
    case TEXTYPE_SHADOWMAP24_RAW: return &textype_shadowmap24_raw;
    case TEXTYPE_SRGB_DXT1: return &textype_sRGB_dxt1;
    case TEXTYPE_SRGB_DXT1A: return &textype_sRGB_dxt1a;
    case TEXTYPE_SRGB_DXT3: return &textype_sRGB_dxt3;
    case TEXTYPE_SRGB_DXT5: return &textype_sRGB_dxt5;
    case TEXTYPE_SRGB_PALETTE: return (flags & TEXF_ALPHA) ? &textype_sRGB_palette_alpha : &textype_sRGB_palette;
    case TEXTYPE_SRGB_RGBA: return ((flags & TEXF_COMPRESS) && vid.support.ext_texture_compression_s3tc) ? ((flags & TEXF_ALPHA) ? &textype_sRGB_rgba_alpha_compress : &textype_sRGB_rgba_compress) : ((flags & TEXF_ALPHA) ? &textype_sRGB_rgba_alpha : &textype_sRGB_rgba);
    case TEXTYPE_SRGB_BGRA: return ((flags & TEXF_COMPRESS) && vid.support.ext_texture_compression_s3tc) ? ((flags & TEXF_ALPHA) ? &textype_sRGB_bgra_alpha_compress : &textype_sRGB_bgra_compress) : ((flags & TEXF_ALPHA) ? &textype_sRGB_bgra_alpha : &textype_sRGB_bgra);
#endif
    default:
        Host_Error("R_GetTexTypeInfo: unknown texture format %i with flags %x", (int)textype, flags);
        break;
    }
    return NULL;
}

References viddef_support_t::ext_texture_compression_s3tc, flags, Host_Error(), NULL, viddef_t::support, TEXF_ALPHA, TEXF_COMPRESS, TEXTYPE_ALPHA, textype_alpha, TEXTYPE_BGRA, textype_bgra, textype_bgra_alpha, textype_bgra_alpha_compress, textype_bgra_compress, TEXTYPE_COLORBUFFER, textype_colorbuffer, TEXTYPE_COLORBUFFER16F, textype_colorbuffer16f, TEXTYPE_COLORBUFFER32F, textype_colorbuffer32f, textype_depth16, textype_depth24, textype_depth24stencil8, TEXTYPE_DEPTHBUFFER16, TEXTYPE_DEPTHBUFFER24, TEXTYPE_DEPTHBUFFER24STENCIL8, TEXTYPE_DXT1, textype_dxt1, TEXTYPE_DXT1A, textype_dxt1a, TEXTYPE_DXT3, textype_dxt3, TEXTYPE_DXT5, textype_dxt5, TEXTYPE_ETC1, TEXTYPE_PALETTE, textype_palette, textype_palette_alpha, TEXTYPE_RGBA, textype_rgba, textype_rgba_alpha, textype_rgba_alpha_compress, textype_rgba_compress, TEXTYPE_SHADOWMAP16_COMP, textype_shadowmap16_comp, TEXTYPE_SHADOWMAP16_RAW, textype_shadowmap16_raw, TEXTYPE_SHADOWMAP24_COMP, textype_shadowmap24_comp, TEXTYPE_SHADOWMAP24_RAW, textype_shadowmap24_raw, TEXTYPE_SRGB_BGRA, textype_sRGB_bgra, textype_sRGB_bgra_alpha, textype_sRGB_bgra_alpha_compress, textype_sRGB_bgra_compress, TEXTYPE_SRGB_DXT1, textype_sRGB_dxt1, TEXTYPE_SRGB_DXT1A, textype_sRGB_dxt1a, TEXTYPE_SRGB_DXT3, textype_sRGB_dxt3, TEXTYPE_SRGB_DXT5, textype_sRGB_dxt5, TEXTYPE_SRGB_PALETTE, textype_sRGB_palette, textype_sRGB_palette_alpha, TEXTYPE_SRGB_RGBA, textype_sRGB_rgba, textype_sRGB_rgba_alpha, textype_sRGB_rgba_alpha_compress, textype_sRGB_rgba_compress, and vid.

Referenced by R_LoadTextureDDSFile(), R_LoadTextureRenderBuffer(), and R_SetupTexture().

R_LoadTexture2D()

rtexture_t * R_LoadTexture2D	(	rtexturepool_t *	rtexturepool,
		const char *	identifier,
		int	width,
		int	height,
		const unsigned char *	data,
		textype_t	textype,
		int	flags,
		int	miplevel,
		const unsigned int *	palette )

Definition at line 1352 of file gl_textures.c.

{
    return R_SetupTexture(rtexturepool, identifier, width, height, 1, 1, flags, miplevel, textype, GLTEXTURETYPE_2D, data, palette);
}

References data, flags, GLTEXTURETYPE_2D, height, R_SetupTexture(), and width.

Referenced by loadtextureimage(), Mod_GenerateLightmaps_CreateLightmaps(), Mod_Q1BSP_LoadFaces(), Mod_Q3BSP_LoadLightmaps(), Mod_VBSP_LoadFaces(), R_Bloom_StartFrame(), R_BuildBlankTextures(), R_BuildFogHeightTexture(), R_BuildFogTexture(), R_BuildNoTexture(), r_explosion_start(), R_InitParticleTexture(), R_RenderTarget_Get(), R_Shadow_MakeShadowMap(), R_Shadow_MakeTextures(), R_Shadow_PrepareLights(), R_SkinFrame_GenerateTexturesFromQPixels(), R_SkinFrame_LoadExternal_SkinFrame(), R_SkinFrame_LoadInternal8bit(), R_SkinFrame_LoadInternalBGRA(), R_UpdateVariables(), and SCR_SetLoadingScreenTexture().

R_LoadTexture3D()

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,
		int	miplevel,
		const unsigned int *	palette )

Definition at line 1357 of file gl_textures.c.

{
    return R_SetupTexture(rtexturepool, identifier, width, height, depth, 1, flags, miplevel, textype, GLTEXTURETYPE_3D, data, palette);
}

References data, depth, flags, GLTEXTURETYPE_3D, height, R_SetupTexture(), and width.

Referenced by Mod_Q3BSP_LoadLightGrid(), and R_Shadow_BounceGrid_ConvertPixelsAndUpload().

R_LoadTextureCubeMap()

rtexture_t * R_LoadTextureCubeMap	(	rtexturepool_t *	rtexturepool,
		const char *	identifier,
		int	width,
		const unsigned char *	data,
		textype_t	textype,
		int	flags,
		int	miplevel,
		const unsigned int *	palette )

Definition at line 1362 of file gl_textures.c.

{
    return R_SetupTexture(rtexturepool, identifier, width, width, 1, 6, flags, miplevel, textype, GLTEXTURETYPE_CUBEMAP, data, palette);
}

References data, flags, GLTEXTURETYPE_CUBEMAP, R_SetupTexture(), and width.

Referenced by R_BuildNormalizationCube(), R_BuildWhiteCube(), R_LoadCubemap(), and R_Shadow_MakeVSDCT().

R_LoadTextureDDSFile()

rtexture_t * R_LoadTextureDDSFile	(	rtexturepool_t *	rtexturepool,
		const char *	filename,
		qbool	srgb,
		int	flags,
		qbool *	hasalphaflag,
		float *	avgcolor,
		int	miplevel,
		qbool	optionaltexture )

Definition at line 1569 of file gl_textures.c.

{
    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, mipsize_total;
    unsigned int c, r, g, b;
    GLint oldbindtexnum = 0;
    unsigned char *mippixels;
    unsigned char *mippixels_start;
    unsigned char *ddspixels;
    unsigned char *dds;
    fs_offset_t ddsfilesize;
    unsigned int ddssize;
    qbool force_swdecode;
#ifdef __ANDROID__
    // ELUAN: FIXME: separate this code
    char vabuf[1024];
    char vabuf2[1024];
    int strsize;
    KTX_dimensions sizes;
#endif
 
    if (cls.state == ca_dedicated)
        return NULL;
 
#ifdef __ANDROID__
    // ELUAN: FIXME: separate this code
    if (vid.renderpath != RENDERPATH_GLES2)
    {
        Con_DPrintf("KTX texture format is only supported on the GLES2 renderpath\n");
        return NULL;
    }
 
    // some textures are specified with extensions, so it becomes .tga.dds
    FS_StripExtension (filename, vabuf2, sizeof(vabuf2));
    FS_StripExtension (vabuf2, vabuf, sizeof(vabuf));
    FS_DefaultExtension (vabuf, ".ktx", sizeof(vabuf));
    strsize = strlen(vabuf);
    if (strsize > 5)
    for (i = 0; i <= strsize - 4; i++) // copy null termination
        vabuf[i] = vabuf[i + 4];
 
    Con_DPrintf("Loading %s...\n", vabuf);
    dds = FS_LoadFile(vabuf, tempmempool, true, &ddsfilesize);
    ddssize = ddsfilesize;
 
    if (!dds)
    {
        Con_DPrintf("Not found!\n");
        return NULL; // not found
    }
    Con_DPrintf("Found!\n");
 
    if (flags & TEXF_ALPHA)
    {
        Con_DPrintf("KTX texture with alpha not supported yet, disabling\n");
        flags &= ~TEXF_ALPHA;
    }
 
    {
        GLenum target;
        GLenum glerror;
        GLboolean isMipmapped;
        KTX_error_code ktxerror;
 
        glt = (gltexture_t *)Mem_ExpandableArray_AllocRecord(&texturearray);
 
        // texture uploading can take a while, so make sure we're sending keepalives
        CL_KeepaliveMessage(false);
 
        // create the texture object
        CHECKGLERROR
        GL_ActiveTexture(0);
        oldbindtexnum = R_Mesh_TexBound(0, gltexturetypeenums[GLTEXTURETYPE_2D]);
        qglGenTextures(1, (GLuint *)&glt->texnum);CHECKGLERROR
        qglBindTexture(gltexturetypeenums[GLTEXTURETYPE_2D], glt->texnum);CHECKGLERROR
 
        // upload the texture
        // we need to restore the texture binding after finishing the upload
 
        // NOTE: some drivers fail with ETC1 NPOT (only PowerVR?). This may make the driver crash later.
        ktxerror = ktxLoadTextureM(dds, ddssize, &glt->texnum, &target, &sizes, &isMipmapped, &glerror,
                                0, NULL);// can't CHECKGLERROR, the lib catches it
 
        // FIXME: delete texture if we fail here
        if (target != GL_TEXTURE_2D)
        {
            qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR
            Mem_Free(dds);
            Con_DPrintf("%s target != GL_TEXTURE_2D, target == %x\n", vabuf, target);
            return NULL; // FIXME: delete the texture from memory
        }
 
        if (KTX_SUCCESS == ktxerror)
        {
            textype = TEXTYPE_ETC1;
            flags &= ~TEXF_COMPRESS; // don't let the textype be wrong
 
            // return whether this texture is transparent
            if (hasalphaflag)
                *hasalphaflag = (flags & TEXF_ALPHA) != 0;
 
            // TODO: apply gl_picmip
            // TODO: avgcolor
            // TODO: srgb
            // TODO: only load mipmaps if requested
 
            if (isMipmapped)
                flags |= TEXF_MIPMAP;
            else
                flags &= ~TEXF_MIPMAP;
 
            texinfo = R_GetTexTypeInfo(textype, flags);
 
            dp_strlcpy(glt->identifier, vabuf, sizeof(glt->identifier));
            glt->pool = pool;
            glt->chain = pool->gltchain;
            pool->gltchain = glt;
            glt->inputwidth = sizes.width;
            glt->inputheight = sizes.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 = sizes.width;
            glt->tileheight = sizes.height;
            glt->tiledepth = 1;
            glt->miplevels = isMipmapped ? 1 : 0; // FIXME
 
                // after upload we have to set some parameters...
#ifdef GL_TEXTURE_MAX_LEVEL
            /* FIXME
                if (dds_miplevels >= 1 && !mipcomplete)
                {
                    // need to set GL_TEXTURE_MAX_LEVEL
                    qglTexParameteri(gltexturetypeenums[glt->texturetype], GL_TEXTURE_MAX_LEVEL, dds_miplevels - 1);CHECKGLERROR
                }
            */
#endif
                GL_SetupTextureParameters(glt->flags, glt->textype->textype, glt->texturetype);
 
                qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR
                Mem_Free(dds);
                return (rtexture_t *)glt;
        }
        else
        {
            qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR
            Mem_Free(dds);
            Con_DPrintf("KTX texture %s failed to load: %x\n", vabuf, ktxerror);
            return NULL;
        }
    }
#endif // __ANDROID__
 
    dds = FS_LoadFile(filename, tempmempool, true, &ddsfilesize);
    ddssize = ddsfilesize;
 
    if (!dds)
    {
        if (r_texture_dds_load_logfailure.integer && (r_texture_dds_load_logfailure.integer >= 2 || !optionaltexture))
            Log_Printf("ddstexturefailures.log", "%s\n", filename);
        return NULL; // not found
    }
 
    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;
    }
 
    //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(r_texture_dds_load_alphamode.integer == 0)
        if(!(dds_format_flags & 0x1)) // DDPF_ALPHAPIXELS
            flags &= ~TEXF_ALPHA;
 
    //flags &= ~TEXF_ALPHA; // disabled, as we DISABLE TEXF_ALPHA in the alpha detection, not enable it!
    if ((dds_format_flags & 0x40) && BuffLittleLong(dds+88) == 32)
    {
        // very sloppy BGRA 32bit identification
        textype = TEXTYPE_BGRA;
        flags &= ~TEXF_COMPRESS; // don't let the textype be wrong
        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;
        }
        if((r_texture_dds_load_alphamode.integer == 1) && (flags & TEXF_ALPHA))
        {
            // 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)
        // LadyHavoc: 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;
        }
        if (flags & TEXF_ALPHA)
        {
            if (r_texture_dds_load_alphamode.integer == 1)
            {
                // check alpha
                for (i = 0;i < size;i += bytesperblock)
                    if (ddspixels[i+0] + ddspixels[i+1] * 256 <= ddspixels[i+2] + ddspixels[i+3] * 256)
                    {
                        // NOTE: this assumes sizeof(unsigned int) == 4
                        unsigned int data = * (unsigned int *) &(ddspixels[i+4]);
                        // check if data, in base 4, contains a digit 3 (DXT1: transparent pixel)
                        if(data & (data<<1) & 0xAAAAAAAA)//rgh
                            break;
                    }
                if (i < size)
                    textype = TEXTYPE_DXT1A;
                else
                    flags &= ~TEXF_ALPHA;
            }
            else if (r_texture_dds_load_alphamode.integer == 0)
                textype = TEXTYPE_DXT1A;
            else
            {
                flags &= ~TEXF_ALPHA;
            }
        }
    }
    else if (!memcmp(dds+84, "DXT3", 4) || !memcmp(dds+84, "DXT2", 4))
    {
        if(!memcmp(dds+84, "DXT2", 4))
        {
            if(!(flags & TEXF_RGBMULTIPLYBYALPHA))
            {
                Con_Printf("^1%s: expecting DXT3 image without premultiplied alpha, got DXT2 image with premultiplied alpha\n", filename);
            }
        }
        else
        {
            if(flags & TEXF_RGBMULTIPLYBYALPHA)
            {
                Con_Printf("^1%s: expecting DXT2 image without premultiplied alpha, got DXT3 image without premultiplied alpha\n", filename);
            }
        }
        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;
        }
        // we currently always assume alpha
    }
    else if (!memcmp(dds+84, "DXT5", 4) || !memcmp(dds+84, "DXT4", 4))
    {
        if(!memcmp(dds+84, "DXT4", 4))
        {
            if(!(flags & TEXF_RGBMULTIPLYBYALPHA))
            {
                Con_Printf("^1%s: expecting DXT5 image without premultiplied alpha, got DXT4 image with premultiplied alpha\n", filename);
            }
        }
        else
        {
            if(flags & TEXF_RGBMULTIPLYBYALPHA)
            {
                Con_Printf("^1%s: expecting DXT4 image without premultiplied alpha, got DXT5 image without premultiplied alpha\n", filename);
            }
        }
        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;
        }
        // we currently always assume alpha
    }
    else
    {
        Mem_Free(dds);
        Con_Printf("^1%s: unrecognized/unsupported DDS format\n", filename);
        return NULL;
    }
 
    // when requesting a non-alpha texture and we have DXT3/5, convert to DXT1
    if(!(flags & TEXF_ALPHA) && (textype == TEXTYPE_DXT3 || textype == TEXTYPE_DXT5))
    {
        textype = TEXTYPE_DXT1;
        bytesperblock = 8;
        ddssize -= 128;
        ddssize /= 2;
        for (i = 0;i < (int)ddssize;i += bytesperblock)
            memcpy(&ddspixels[i], &ddspixels[(i<<1)+8], 8);
        ddssize += 128;
    }
 
    force_swdecode = false;
    if(bytesperblock)
    {
        if(vid.support.ext_texture_compression_s3tc)
        {
            if(r_texture_dds_swdecode.integer > 1)
                force_swdecode = true;
        }
        else
        {
            if(r_texture_dds_swdecode.integer < 1)
            {
                // unsupported
                Mem_Free(dds);
                return NULL;
            }
            force_swdecode = true;
        }
    }
 
    // return whether this texture is transparent
    if (hasalphaflag)
        *hasalphaflag = (flags & TEXF_ALPHA) != 0;
 
    // if we SW decode, choose 2 sizes bigger
    if(force_swdecode)
    {
        // this is quarter res, so do not scale down more than we have to
        miplevel -= 2;
 
        if(miplevel < 0)
            Con_DPrintf("WARNING: fake software decoding of compressed texture %s degraded quality\n", filename);
    }
 
    // this is where we apply gl_picmip
    mippixels_start = ddspixels;
    mipwidth = dds_width;
    mipheight = dds_height;
    while(miplevel >= 1 && dds_miplevels >= 1)
    {
        if (mipwidth <= 1 && mipheight <= 1)
            break;
        mipsize = bytesperblock ? ((mipwidth+3)/4)*((mipheight+3)/4)*bytesperblock : mipwidth*mipheight*bytesperpixel;
        mippixels_start += mipsize; // just skip
        --dds_miplevels;
        --miplevel;
        if (mipwidth > 1)
            mipwidth >>= 1;
        if (mipheight > 1)
            mipheight >>= 1;
    }
    mipsize_total = ddssize - 128 - (mippixels_start - ddspixels);
    mipsize = bytesperblock ? ((mipwidth+3)/4)*((mipheight+3)/4)*bytesperblock : mipwidth*mipheight*bytesperpixel;
 
    // from here on, we do not need the ddspixels and ddssize any more (apart from the statistics entry in glt)
 
    // fake decode S3TC if needed
    if(force_swdecode)
    {
        int mipsize_new = mipsize_total / bytesperblock * 4;
        unsigned char *mipnewpixels = (unsigned char *) Mem_Alloc(tempmempool, mipsize_new);
        unsigned char *p = mipnewpixels;
        for (i = bytesperblock == 16 ? 8 : 0;i < (int)mipsize_total;i += bytesperblock, p += 4)
        {
            // UBSan: unsigned literals because promotion to int causes signed overflow when mippixels_start >= 128
            c = mippixels_start[i] + 256u*mippixels_start[i+1] + 65536u*mippixels_start[i+2] + 16777216u*mippixels_start[i+3];
            p[2] = (((c >> 11) & 0x1F) + ((c >> 27) & 0x1F)) * (0.5f / 31.0f * 255.0f);
            p[1] = (((c >>  5) & 0x3F) + ((c >> 21) & 0x3F)) * (0.5f / 63.0f * 255.0f);
            p[0] = (((c      ) & 0x1F) + ((c >> 16) & 0x1F)) * (0.5f / 31.0f * 255.0f);
            if(textype == TEXTYPE_DXT5)
                p[3] = (0.5 * mippixels_start[i-8] + 0.5 * mippixels_start[i-7]);
            else if(textype == TEXTYPE_DXT3)
                p[3] = (
                      (mippixels_start[i-8] & 0x0F)
                    + (mippixels_start[i-8] >> 4)
                    + (mippixels_start[i-7] & 0x0F)
                    + (mippixels_start[i-7] >> 4)
                    + (mippixels_start[i-6] & 0x0F)
                    + (mippixels_start[i-6] >> 4)
                    + (mippixels_start[i-5] & 0x0F)
                    + (mippixels_start[i-5] >> 4)
                       ) * (0.125f / 15.0f * 255.0f);
            else
                p[3] = 255;
        }
 
        textype = TEXTYPE_BGRA;
        bytesperblock = 0;
        bytesperpixel = 4;
 
        // as each block becomes a pixel, we must use pixel count for this
        mipwidth = (mipwidth + 3) / 4;
        mipheight = (mipheight + 3) / 4;
        mipsize = bytesperpixel * mipwidth * mipheight;
        mippixels_start = mipnewpixels;
        mipsize_total = mipsize_new;
    }
 
    // start mip counting
    mippixels = mippixels_start;
 
    // calculate average color if requested
    if (avgcolor)
    {
        float f;
        Vector4Clear(avgcolor);
        if (bytesperblock)
        {
            for (i = bytesperblock == 16 ? 8 : 0;i < mipsize;i += bytesperblock)
            {
                // UBSan: unsigned literals because promotion to int causes signed overflow when mippixels >= 128
                c = mippixels[i] + 256u*mippixels[i+1] + 65536u*mippixels[i+2] + 16777216u*mippixels[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);
                if(textype == TEXTYPE_DXT5)
                    avgcolor[3] += (mippixels[i-8] + (int) mippixels[i-7]) * (0.5f / 255.0f);
                else if(textype == TEXTYPE_DXT3)
                    avgcolor[3] += (
                          (mippixels_start[i-8] & 0x0F)
                        + (mippixels_start[i-8] >> 4)
                        + (mippixels_start[i-7] & 0x0F)
                        + (mippixels_start[i-7] >> 4)
                        + (mippixels_start[i-6] & 0x0F)
                        + (mippixels_start[i-6] >> 4)
                        + (mippixels_start[i-5] & 0x0F)
                        + (mippixels_start[i-5] >> 4)
                           ) * (0.125f / 15.0f);
                else
                    avgcolor[3] += 1.0f;
            }
            f = (float)bytesperblock / mipsize;
            avgcolor[0] *= (0.5f / 31.0f) * f;
            avgcolor[1] *= (0.5f / 63.0f) * f;
            avgcolor[2] *= (0.5f / 31.0f) * f;
            avgcolor[3] *= f;
        }
        else
        {
            for (i = 0;i < mipsize;i += 4)
            {
                avgcolor[0] += mippixels[i+2];
                avgcolor[1] += mippixels[i+1];
                avgcolor[2] += mippixels[i];
                avgcolor[3] += mippixels[i+3];
            }
            f = (1.0f / 255.0f) * bytesperpixel / mipsize;
            avgcolor[0] *= f;
            avgcolor[1] *= f;
            avgcolor[2] *= f;
            avgcolor[3] *= f;
        }
    }
 
    // if we want sRGB, convert now
    if(srgb)
    {
        if (vid.support.ext_texture_srgb)
        {
            switch(textype)
            {
            case TEXTYPE_DXT1:    textype = TEXTYPE_SRGB_DXT1   ;break;
            case TEXTYPE_DXT1A:   textype = TEXTYPE_SRGB_DXT1A  ;break;
            case TEXTYPE_DXT3:    textype = TEXTYPE_SRGB_DXT3   ;break;
            case TEXTYPE_DXT5:    textype = TEXTYPE_SRGB_DXT5   ;break;
            case TEXTYPE_RGBA:    textype = TEXTYPE_SRGB_RGBA   ;break;
            default:
                break;
            }
        }
        else
        {
            switch(textype)
            {
            case TEXTYPE_DXT1:
            case TEXTYPE_DXT1A:
            case TEXTYPE_DXT3:
            case TEXTYPE_DXT5:
                {
                    for (i = bytesperblock == 16 ? 8 : 0;i < mipsize_total;i += bytesperblock)
                    {
                        int c0, c1, c0new, c1new;
                        c0 = mippixels_start[i] + 256*mippixels_start[i+1];
                        r = ((c0 >> 11) & 0x1F);
                        g = ((c0 >>  5) & 0x3F);
                        b = ((c0      ) & 0x1F);
                        r = floor(Image_LinearFloatFromsRGB(r * (255.0f / 31.0f)) * 31.0f + 0.5f); // these multiplications here get combined with multiplications in Image_LinearFloatFromsRGB
                        g = floor(Image_LinearFloatFromsRGB(g * (255.0f / 63.0f)) * 63.0f + 0.5f); // these multiplications here get combined with multiplications in Image_LinearFloatFromsRGB
                        b = floor(Image_LinearFloatFromsRGB(b * (255.0f / 31.0f)) * 31.0f + 0.5f); // these multiplications here get combined with multiplications in Image_LinearFloatFromsRGB
                        c0new = (r << 11) | (g << 5) | b;
                        c1 = mippixels_start[i+2] + 256*mippixels_start[i+3];
                        r = ((c1 >> 11) & 0x1F);
                        g = ((c1 >>  5) & 0x3F);
                        b = ((c1      ) & 0x1F);
                        r = floor(Image_LinearFloatFromsRGB(r * (255.0f / 31.0f)) * 31.0f + 0.5f); // these multiplications here get combined with multiplications in Image_LinearFloatFromsRGB
                        g = floor(Image_LinearFloatFromsRGB(g * (255.0f / 63.0f)) * 63.0f + 0.5f); // these multiplications here get combined with multiplications in Image_LinearFloatFromsRGB
                        b = floor(Image_LinearFloatFromsRGB(b * (255.0f / 31.0f)) * 31.0f + 0.5f); // these multiplications here get combined with multiplications in Image_LinearFloatFromsRGB
                        c1new = (r << 11) | (g << 5) | b;
                        // swap the colors if needed to fix order
                        if(c0 > c1) // thirds
                        {
                            if(c0new < c1new)
                            {
                                c = c0new;
                                c0new = c1new;
                                c1new = c;
                                if(c0new == c1new)
                                mippixels_start[i+4] ^= 0x55;
                                mippixels_start[i+5] ^= 0x55;
                                mippixels_start[i+6] ^= 0x55;
                                mippixels_start[i+7] ^= 0x55;
                            }
                            else if(c0new == c1new)
                            {
                                mippixels_start[i+4] = 0x00;
                                mippixels_start[i+5] = 0x00;
                                mippixels_start[i+6] = 0x00;
                                mippixels_start[i+7] = 0x00;
                            }
                        }
                        else // half + transparent
                        {
                            if(c0new > c1new)
                            {
                                c = c0new;
                                c0new = c1new;
                                c1new = c;
                                mippixels_start[i+4] ^= (~mippixels_start[i+4] >> 1) & 0x55;
                                mippixels_start[i+5] ^= (~mippixels_start[i+5] >> 1) & 0x55;
                                mippixels_start[i+6] ^= (~mippixels_start[i+6] >> 1) & 0x55;
                                mippixels_start[i+7] ^= (~mippixels_start[i+7] >> 1) & 0x55;
                            }
                        }
                        mippixels_start[i] = c0new & 255;
                        mippixels_start[i+1] = c0new >> 8;
                        mippixels_start[i+2] = c1new & 255;
                        mippixels_start[i+3] = c1new >> 8;
                    }
                }
                break;
            case TEXTYPE_RGBA:
                Image_MakeLinearColorsFromsRGB(mippixels, mippixels, mipsize_total / bytesperblock);
                break;
            default:
                break;
            }
        }
    }
 
    // when not requesting mipmaps, do not load them
    if(!(flags & TEXF_MIPMAP))
        dds_miplevels = 0;
 
    if (dds_miplevels >= 1)
        flags |= TEXF_MIPMAP;
    else
        flags &= ~TEXF_MIPMAP;
 
    texinfo = R_GetTexTypeInfo(textype, flags);
 
    glt = (gltexture_t *)Mem_ExpandableArray_AllocRecord(&texturearray);
    dp_strlcpy (glt->identifier, filename, sizeof(glt->identifier));
    glt->pool = pool;
    glt->chain = pool->gltchain;
    pool->gltchain = glt;
    glt->inputwidth = mipwidth;
    glt->inputheight = mipheight;
    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 = mipwidth;
    glt->tileheight = mipheight;
    glt->tiledepth = 1;
    glt->miplevels = dds_miplevels;
 
    // texture uploading can take a while, so make sure we're sending keepalives
    CL_KeepaliveMessage(false);
 
    // create the texture object
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        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
        break;
    }
 
    // upload the texture
    // we need to restore the texture binding after finishing the upload
    mipcomplete = false;
 
    for (mip = 0;mip <= dds_miplevels;mip++) // <= to include the not-counted "largest" miplevel
    {
        unsigned char *upload_mippixels = mippixels;
        int upload_mipwidth = mipwidth;
        int upload_mipheight = mipheight;
        mipsize = bytesperblock ? ((mipwidth+3)/4)*((mipheight+3)/4)*bytesperblock : mipwidth*mipheight*bytesperpixel;
        if (mippixels + mipsize > mippixels_start + mipsize_total)
            break;
        switch(vid.renderpath)
        {
        case RENDERPATH_GL32:
        case RENDERPATH_GLES2:
            if (bytesperblock)
            {
                qglCompressedTexImage2D(GL_TEXTURE_2D, mip, glt->glinternalformat, upload_mipwidth, upload_mipheight, 0, mipsize, upload_mippixels);CHECKGLERROR
            }
            else
            {
                qglTexImage2D(GL_TEXTURE_2D, mip, glt->glinternalformat, upload_mipwidth, upload_mipheight, 0, glt->glformat, glt->gltype, upload_mippixels);CHECKGLERROR
            }
            break;
        }
        if(upload_mippixels != mippixels)
            Mem_Free(upload_mippixels);
        mippixels += mipsize;
        if (mipwidth <= 1 && mipheight <= 1)
        {
            mipcomplete = true;
            break;
        }
        if (mipwidth > 1)
            mipwidth >>= 1;
        if (mipheight > 1)
            mipheight >>= 1;
    }
 
    // after upload we have to set some parameters...
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
#ifdef GL_TEXTURE_MAX_LEVEL
        if (dds_miplevels >= 1 && !mipcomplete)
        {
            // need to set GL_TEXTURE_MAX_LEVEL
            qglTexParameteri(gltexturetypeenums[glt->texturetype], GL_TEXTURE_MAX_LEVEL, dds_miplevels - 1);CHECKGLERROR
        }
#endif
        GL_SetupTextureParameters(glt->flags, glt->textype->textype, glt->texturetype);
        qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR
        break;
    }
 
    Mem_Free(dds);
    if(force_swdecode)
        Mem_Free((unsigned char *) mippixels_start);
    return (rtexture_t *)glt;
}

References b, BuffLittleLong(), gltexture_t::bytesperpixel, ca_dedicated, gltexture_t::chain, CHECKGLERROR, CL_KeepaliveMessage(), cls, Con_DPrintf(), Con_Printf(), data, dp_strlcpy, viddef_support_t::ext_texture_compression_s3tc, viddef_support_t::ext_texture_srgb, f, flags, gltexture_t::flags, float, floor(), FS_DefaultExtension(), FS_LoadFile(), FS_StripExtension(), g, GL_ActiveTexture(), GL_SetupTextureParameters(), GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, gltexture_t::glformat, textypeinfo_t::glformat, gltexture_t::glinternalformat, textypeinfo_t::glinternalformat, gltexturepool_t::gltchain, GLTEXTURETYPE_2D, gltexture_t::gltexturetypeenum, gltexturetypeenums, gltexture_t::gltype, textypeinfo_t::gltype, i, gltexture_t::identifier, Image_LinearFloatFromsRGB, Image_MakeLinearColorsFromsRGB(), gltexture_t::inputdatasize, gltexture_t::inputdepth, gltexture_t::inputheight, gltexture_t::inputwidth, int(), cvar_t::integer, textypeinfo_t::internalbytesperpixel, INTOVERFLOW_ADD, INTOVERFLOW_DIV, INTOVERFLOW_MUL, INTOVERFLOW_NORMALIZE, Log_Printf(), Mem_Alloc, Mem_ExpandableArray_AllocRecord(), Mem_Free, gltexture_t::miplevels, NULL, gltexture_t::pool, r, R_GetTexTypeInfo(), R_Mesh_TexBound(), r_texture_dds_load_alphamode, r_texture_dds_load_logfailure, r_texture_dds_swdecode, viddef_t::renderpath, RENDERPATH_GL32, RENDERPATH_GLES2, gltexture_t::sides, size, client_static_t::state, strlen(), viddef_t::support, target, tempmempool, TEXF_ALPHA, TEXF_MIPMAP, TEXF_RGBMULTIPLYBYALPHA, gltexture_t::texnum, texturearray, gltexture_t::texturetype, gltexture_t::textype, textypeinfo_t::textype, TEXTYPE_BGRA, TEXTYPE_DXT1, TEXTYPE_DXT1A, TEXTYPE_DXT3, TEXTYPE_DXT5, TEXTYPE_ETC1, TEXTYPE_RGBA, TEXTYPE_SRGB_DXT1, TEXTYPE_SRGB_DXT1A, TEXTYPE_SRGB_DXT3, TEXTYPE_SRGB_DXT5, TEXTYPE_SRGB_RGBA, gltexture_t::tiledepth, gltexture_t::tileheight, gltexture_t::tilewidth, Vector4Clear, and vid.

Referenced by R_SkinFrame_LoadExternal_SkinFrame().

R_LoadTextureRenderBuffer()

rtexture_t * R_LoadTextureRenderBuffer	(	rtexturepool_t *	rtexturepool,
		const char *	identifier,
		int	width,
		int	height,
		textype_t	textype )

Definition at line 1372 of file gl_textures.c.

{
    gltexture_t *glt;
    gltexturepool_t *pool = (gltexturepool_t *)rtexturepool;
    textypeinfo_t *texinfo;
 
    if (cls.state == ca_dedicated)
        return NULL;
 
    texinfo = R_GetTexTypeInfo(textype, TEXF_RENDERTARGET | TEXF_CLAMP);
 
    glt = (gltexture_t *)Mem_ExpandableArray_AllocRecord(&texturearray);
    if (identifier)
        dp_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 = 1;
    glt->flags = TEXF_RENDERTARGET | TEXF_CLAMP | TEXF_FORCENEAREST;
    glt->miplevel = 0;
    glt->textype = texinfo;
    glt->texturetype = textype;
    glt->inputdatasize = width*height*texinfo->internalbytesperpixel;
    glt->palette = NULL;
    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->glisdepthstencil = textype == TEXTYPE_DEPTHBUFFER24STENCIL8;
    glt->gltexturetypeenum = GL_TEXTURE_2D;
    // init the dynamic texture attributes, too [11/22/2007 Black]
    glt->updatecallback = NULL;
    glt->updatecallback_data = NULL;
 
    GL_Texture_CalcImageSize(glt->texturetype, glt->flags, glt->miplevel, glt->inputwidth, glt->inputheight, glt->inputdepth, &glt->tilewidth, &glt->tileheight, &glt->tiledepth, &glt->miplevels);
 
    // upload the texture
    // data may be NULL (blank texture for dynamic rendering)
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        CHECKGLERROR
        qglGenRenderbuffers(1, (GLuint *)&glt->renderbuffernum);CHECKGLERROR
        qglBindRenderbuffer(GL_RENDERBUFFER, glt->renderbuffernum);CHECKGLERROR
        qglRenderbufferStorage(GL_RENDERBUFFER, glt->glinternalformat, glt->tilewidth, glt->tileheight);CHECKGLERROR
        // note we can query the renderbuffer for info with glGetRenderbufferParameteriv for GL_WIDTH, GL_HEIGHt, GL_RED_SIZE, GL_GREEN_SIZE, GL_BLUE_SIZE, GL_GL_ALPHA_SIZE, GL_DEPTH_SIZE, GL_STENCIL_SIZE, GL_INTERNAL_FORMAT
        qglBindRenderbuffer(GL_RENDERBUFFER, 0);CHECKGLERROR
        break;
    }
 
    return (rtexture_t *)glt;
}

References gltexture_t::bytesperpixel, ca_dedicated, gltexture_t::chain, CHECKGLERROR, cls, gltexture_t::dirty, dp_strlcpy, gltexture_t::flags, GL_RENDERBUFFER, GL_TEXTURE_2D, GL_Texture_CalcImageSize(), gltexture_t::glformat, textypeinfo_t::glformat, gltexture_t::glinternalformat, textypeinfo_t::glinternalformat, gltexture_t::glisdepthstencil, gltexturepool_t::gltchain, GLTEXTURETYPE_CUBEMAP, gltexture_t::gltexturetypeenum, gltexture_t::gltype, textypeinfo_t::gltype, height, gltexture_t::identifier, gltexture_t::inputdatasize, gltexture_t::inputdepth, gltexture_t::inputheight, gltexture_t::inputwidth, textypeinfo_t::internalbytesperpixel, Mem_ExpandableArray_AllocRecord(), gltexture_t::miplevel, gltexture_t::miplevels, NULL, gltexture_t::palette, gltexture_t::pool, R_GetTexTypeInfo(), gltexture_t::renderbuffernum, viddef_t::renderpath, RENDERPATH_GL32, RENDERPATH_GLES2, gltexture_t::sides, client_static_t::state, TEXF_CLAMP, TEXF_FORCENEAREST, TEXF_RENDERTARGET, gltexture_t::texnum, texturearray, gltexture_t::texturetype, gltexture_t::textype, TEXTYPE_DEPTHBUFFER24STENCIL8, gltexture_t::tiledepth, gltexture_t::tileheight, gltexture_t::tilewidth, gltexture_t::updatecallback, gltexture_t::updatecallback_data, vid, and width.

Referenced by R_RenderTarget_Get(), R_Shadow_MakeShadowMap(), and R_Shadow_PrepareLights().

R_LoadTextureShadowMap2D()

rtexture_t * R_LoadTextureShadowMap2D	(	rtexturepool_t *	rtexturepool,
		const char *	identifier,
		int	width,
		int	height,
		textype_t	textype,
		qbool	filter )

Definition at line 1367 of file gl_textures.c.

{
    return R_SetupTexture(rtexturepool, identifier, width, height, 1, 1, TEXF_RENDERTARGET | TEXF_CLAMP | (filter ? TEXF_FORCELINEAR : TEXF_FORCENEAREST), -1, textype, GLTEXTURETYPE_2D, NULL, NULL);
}

References filter, GLTEXTURETYPE_2D, height, NULL, R_SetupTexture(), TEXF_CLAMP, TEXF_FORCELINEAR, TEXF_FORCENEAREST, TEXF_RENDERTARGET, and width.

Referenced by R_Shadow_MakeShadowMap().

R_MakeResizeBufferBigger()

static void R_MakeResizeBufferBigger ( int size )

static

Definition at line 821 of file gl_textures.c.

{
    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");
    }
}

References colorconvertbuffer, Host_Error(), Mem_Alloc, Mem_Free, resizebuffer, resizebuffersize, size, and texturemempool.

Referenced by R_UploadFullTexture().

R_MakeTextureDynamic()

void R_MakeTextureDynamic	(	rtexture_t *	rt,
		updatecallback_t	updatecallback,
		void *	data )

Definition at line 326 of file gl_textures.c.

                                                                                       {
    gltexture_t *glt = (gltexture_t*) rt;
    if( !glt ) {
        return;
    }
 
    glt->flags |= GLTEXF_DYNAMIC;
    glt->updatecallback = updatecallback;
    glt->updatecallback_data = data;
}

References data, gltexture_t::flags, GLTEXF_DYNAMIC, gltexture_t::updatecallback, and gltexture_t::updatecallback_data.

Referenced by LinkVideoTexture().

R_MarkDirtyTexture()

void R_MarkDirtyTexture

(

rtexture_t *

rt

)

Definition at line 312 of file gl_textures.c.

                                        {
    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;
    }
}

References gltexture_t::dirty, gltexture_t::flags, and GLTEXF_DYNAMIC.

Referenced by CL_Video_Frame().

R_PicmipForFlags()

int R_PicmipForFlags

(

int

flags

)

Definition at line 2394 of file gl_textures.c.

{
    int miplevel = 0;
    if(flags & TEXF_PICMIP)
    {
        miplevel += gl_picmip.integer;
        if (flags & TEXF_ISWORLD)
        {
            if (r_picmipworld.integer)
                miplevel += gl_picmip_world.integer;
            else
                miplevel = 0;
        }
        else if (flags & TEXF_ISSPRITE)
        {
            if (r_picmipsprites.integer)
                miplevel += gl_picmip_sprites.integer;
            else
                miplevel = 0;
        }
        else
            miplevel += gl_picmip_other.integer;
    }
    return max(0, miplevel);
}

References flags, gl_picmip, gl_picmip_other, gl_picmip_sprites, gl_picmip_world, cvar_t::integer, max, r_picmipsprites, r_picmipworld, TEXF_ISSPRITE, TEXF_ISWORLD, and TEXF_PICMIP.

Referenced by loadtextureimage(), R_SetupTexture(), and R_SkinFrame_LoadExternal_SkinFrame().

R_PurgeTexture()

void R_PurgeTexture

(

rtexture_t *

rt

)

Definition at line 344 of file gl_textures.c.

{
    if(rt && !(((gltexture_t*) rt)->flags & TEXF_PERSISTENT)) {
        R_FreeTexture(rt);
    }
}

References flags, R_FreeTexture(), and TEXF_PERSISTENT.

Referenced by R_SkinFrame_PurgeSkinFrame().

R_RealGetTexture()

int R_RealGetTexture

(

rtexture_t *

rt

)

Definition at line 2358 of file gl_textures.c.

{
    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;
            // Because we currently don't set the relevant upload stride parameters, just make it full width.
            glt->modified_mins[0] = 0;
            glt->modified_maxs[0] = glt->tilewidth;
            // Check also if it's updating at least half the height of the texture.
            if (glt->modified_maxs[1] - glt->modified_mins[1] > glt->tileheight / 2)
                R_UploadFullTexture(glt, glt->bufferpixels);
            else
                R_UploadPartialTexture(glt, glt->bufferpixels + (size_t)glt->modified_mins[1] * glt->tilewidth * glt->bytesperpixel, glt->modified_mins[0], glt->modified_mins[1], glt->modified_mins[2], glt->modified_maxs[0] - glt->modified_mins[0], glt->modified_maxs[1] - glt->modified_mins[1], glt->modified_maxs[2] - glt->modified_mins[2]);
        }
        VectorClear(glt->modified_mins);
        VectorClear(glt->modified_maxs);
        glt->dirty = false;
        return glt->texnum;
    }
    else
        return r_texture_white->texnum;
}

References gltexture_t::buffermodified, gltexture_t::bufferpixels, gltexture_t::bytesperpixel, gltexture_t::dirty, gltexture_t::flags, GLTEXF_DYNAMIC, gltexture_t::modified_maxs, gltexture_t::modified_mins, r_texture_white, R_UpdateDynamicTexture(), R_UploadFullTexture(), R_UploadPartialTexture(), gltexture_t::texnum, rtexture_t::texnum, gltexture_t::tileheight, gltexture_t::tilewidth, and VectorClear.

R_SaveTextureDDSFile()

int R_SaveTextureDDSFile	(	rtexture_t *	rt,
		const char *	filename,
		qbool	skipuncompressed,
		qbool	hasalpha )

Definition at line 1431 of file gl_textures.c.

{
#ifdef USE_GLES2
    return -1; // unsupported on this platform
#else
    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)
    {
    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;
    }
    // if premultiplied alpha, say so in the DDS file
    if(glt->flags & TEXF_RGBMULTIPLYBYALPHA)
    {
        switch(internalformat)
        {
            case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: ddsfourcc = "DXT2";break;
            case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: ddsfourcc = "DXT4";break;
        }
    }
    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) && !(glt->tilewidth == 1 && glt->tileheight == 1))
    {
        for (mip = 1;mip < 16;mip++)
        {
            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;
            }
        }
        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 = (unsigned char *)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
    {
        dds_flags = 0x100F; // DDSD_CAPS | DDSD_PIXELFORMAT | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PITCH
        dds_format_flags = 0x40; // DDPF_RGB
    }
    if (mipmaps)
    {
        dds_flags |= 0x20000; // DDSD_MIPMAPCOUNT
        dds_caps1 |= 0x400008; // DDSCAPS_MIPMAP | DDSCAPS_COMPLEX
    }
    if(hasalpha)
        dds_format_flags |= 0x1; // DDPF_ALPHAPIXELS
    memcpy(dds, "DDS ", 4);
    StoreLittleLong(dds+4, 124); // http://msdn.microsoft.com/en-us/library/bb943982%28v=vs.85%29.aspx says so
    StoreLittleLong(dds+8, dds_flags);
    StoreLittleLong(dds+12, mipinfo[0][1]); // height
    StoreLittleLong(dds+16, mipinfo[0][0]); // width
    StoreLittleLong(dds+24, 0); // 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++)
        {
            qglGetCompressedTexImage(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;
#endif
}

References CHECKGLERROR, gltexture_t::flags, FS_WriteFile(), GL_ActiveTexture(), GL_BGRA, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_TEXTURE_INTERNAL_FORMAT, GL_UNSIGNED_BYTE, gl_version, gltexturetypeenums, internalformat, Mem_Alloc, Mem_Free, NULL, R_Mesh_TexBound(), ret, StoreLittleLong(), tempmempool, TEXF_MIPMAP, TEXF_RGBMULTIPLYBYALPHA, gltexture_t::texnum, gltexture_t::texturetype, gltexture_t::tileheight, and gltexture_t::tilewidth.

Referenced by R_SkinFrame_LoadExternal_SkinFrame().

R_SetupTexture()

static rtexture_t * R_SetupTexture ( rtexturepool_t * rtexturepool, const char * identifier, int width, int height, int depth, int sides, int flags, int miplevel, textype_t textype, int texturetype, const unsigned char * data, const unsigned int * palette )

static

Definition at line 1126 of file gl_textures.c.

{
    int i, size;
    gltexture_t *glt;
    gltexturepool_t *pool = (gltexturepool_t *)rtexturepool;
    textypeinfo_t *texinfo, *texinfo2;
    unsigned char *temppixels = NULL;
    qbool swaprb;
 
    if (cls.state == ca_dedicated)
        return NULL;
 
    // see if we need to swap red and blue (BGRA <-> RGBA conversion)
    if (textype == TEXTYPE_PALETTE && vid.forcetextype == TEXTYPE_RGBA)
    {
        int numpixels = width * height * depth * sides;
        size = numpixels * 4;
        temppixels = (unsigned char *)Mem_Alloc(tempmempool, size);
        if (data)
        {
            const unsigned char *p;
            unsigned char *o = temppixels;
            for (i = 0;i < numpixels;i++, o += 4)
            {
                p = (const unsigned char *)palette + 4*data[i];
                o[0] = p[2];
                o[1] = p[1];
                o[2] = p[0];
                o[3] = p[3];
            }
        }
        data = temppixels;
        textype = TEXTYPE_RGBA;
    }
    swaprb = false;
    switch(textype)
    {
    case TEXTYPE_RGBA: if (vid.forcetextype == TEXTYPE_BGRA) {swaprb = true;textype = TEXTYPE_BGRA;} break;
    case TEXTYPE_BGRA: if (vid.forcetextype == TEXTYPE_RGBA) {swaprb = true;textype = TEXTYPE_RGBA;} break;
    case TEXTYPE_SRGB_RGBA: if (vid.forcetextype == TEXTYPE_BGRA) {swaprb = true;textype = TEXTYPE_SRGB_BGRA;} break;
    case TEXTYPE_SRGB_BGRA: if (vid.forcetextype == TEXTYPE_RGBA) {swaprb = true;textype = TEXTYPE_SRGB_RGBA;} break;
    default: break;
    }
    if (swaprb)
    {
        // swap bytes
        static int rgbaswapindices[4] = {2, 1, 0, 3};
        size = width * height * depth * sides * 4;
        temppixels = (unsigned char *)Mem_Alloc(tempmempool, size);
        if (data)
            Image_CopyMux(temppixels, data, width, height*depth*sides, false, false, false, 4, 4, rgbaswapindices);
        data = temppixels;
    }
 
    // if sRGB texture formats are not supported, convert input to linear and upload as normal types
    if (!vid.support.ext_texture_srgb)
    {
        qbool convertsRGB = false;
        switch(textype)
        {
        case TEXTYPE_SRGB_DXT1:    textype = TEXTYPE_DXT1   ;convertsRGB = true;break;
        case TEXTYPE_SRGB_DXT1A:   textype = TEXTYPE_DXT1A  ;convertsRGB = true;break;
        case TEXTYPE_SRGB_DXT3:    textype = TEXTYPE_DXT3   ;convertsRGB = true;break;
        case TEXTYPE_SRGB_DXT5:    textype = TEXTYPE_DXT5   ;convertsRGB = true;break;
        case TEXTYPE_SRGB_PALETTE: textype = TEXTYPE_PALETTE;/*convertsRGB = true;*/break;
        case TEXTYPE_SRGB_RGBA:    textype = TEXTYPE_RGBA   ;convertsRGB = true;break;
        case TEXTYPE_SRGB_BGRA:    textype = TEXTYPE_BGRA   ;convertsRGB = true;break;
        default:
            break;
        }
        if (convertsRGB && data)
        {
            size = width * height * depth * sides * 4;
            if (!temppixels)
            {
                temppixels = (unsigned char *)Mem_Alloc(tempmempool, size);
                memcpy(temppixels, data, size);
                data = temppixels;
            }
            Image_MakeLinearColorsFromsRGB(temppixels, temppixels, width*height*depth*sides);
        }
    }
 
    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:
    case TEXTYPE_SRGB_PALETTE:
        if (flags & TEXF_ALPHA)
        {
            flags &= ~TEXF_ALPHA;
            if (data)
            {
                for (i = 0;i < size;i++)
                {
                    if (((unsigned char *)&palette[data[i]])[3] < 255)
                    {
                        flags |= TEXF_ALPHA;
                        break;
                    }
                }
            }
        }
        break;
    case TEXTYPE_RGBA:
    case TEXTYPE_BGRA:
    case TEXTYPE_SRGB_RGBA:
    case TEXTYPE_SRGB_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_SHADOWMAP16_COMP:
    case TEXTYPE_SHADOWMAP16_RAW:
    case TEXTYPE_SHADOWMAP24_COMP:
    case TEXTYPE_SHADOWMAP24_RAW:
        break;
    case TEXTYPE_DXT1:
    case TEXTYPE_SRGB_DXT1:
        break;
    case TEXTYPE_DXT1A:
    case TEXTYPE_SRGB_DXT1A:
    case TEXTYPE_DXT3:
    case TEXTYPE_SRGB_DXT3:
    case TEXTYPE_DXT5:
    case TEXTYPE_SRGB_DXT5:
        flags |= TEXF_ALPHA;
        break;
    case TEXTYPE_ALPHA:
        flags |= TEXF_ALPHA;
        break;
    case TEXTYPE_COLORBUFFER:
    case TEXTYPE_COLORBUFFER16F:
    case TEXTYPE_COLORBUFFER32F:
        flags |= TEXF_ALPHA;
        break;
    default:
        Sys_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)
        dp_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->miplevel = (miplevel < 0) ? R_PicmipForFlags(flags) : miplevel; // note: if miplevel is -1, we know the texture is in original size and we can picmip it normally
    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->glisdepthstencil = false;
    glt->gltexturetypeenum = gltexturetypeenums[glt->texturetype];
    // init the dynamic texture attributes, too [11/22/2007 Black]
    glt->updatecallback = NULL;
    glt->updatecallback_data = NULL;
 
    GL_Texture_CalcImageSize(glt->texturetype, glt->flags, glt->miplevel, glt->inputwidth, glt->inputheight, glt->inputdepth, &glt->tilewidth, &glt->tileheight, &glt->tiledepth, &glt->miplevels);
 
    // upload the texture
    // data may be NULL (blank texture for dynamic rendering)
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        CHECKGLERROR
        qglGenTextures(1, (GLuint *)&glt->texnum);CHECKGLERROR
        break;
    }
 
    R_UploadFullTexture(glt, data);
    if (glt->flags & TEXF_ALLOWUPDATES)
        glt->bufferpixels = (unsigned char *)Mem_Alloc(texturemempool, glt->tilewidth*glt->tileheight*glt->tiledepth*glt->sides*glt->bytesperpixel);
 
    glt->buffermodified = false;
    VectorClear(glt->modified_mins);
    VectorClear(glt->modified_maxs);
 
    // free any temporary processing buffer we allocated...
    if (temppixels)
        Mem_Free(temppixels);
 
    // texture converting and uploading can take a while, so make sure we're sending keepalives
    // FIXME: this causes rendering during R_Shadow_DrawLights
//  CL_KeepaliveMessage(false);
 
    return (rtexture_t *)glt;
}

References gltexture_t::buffermodified, gltexture_t::bufferpixels, gltexture_t::bytesperpixel, ca_dedicated, gltexture_t::chain, CHECKGLERROR, cls, Con_Printf(), data, depth, gltexture_t::dirty, dp_strlcpy, viddef_support_t::ext_texture_srgb, flags, gltexture_t::flags, viddef_t::forcetextype, GL_Texture_CalcImageSize(), gltexture_t::glformat, textypeinfo_t::glformat, gltexture_t::glinternalformat, textypeinfo_t::glinternalformat, gltexture_t::glisdepthstencil, gltexturepool_t::gltchain, GLTEXTURETYPE_CUBEMAP, gltexture_t::gltexturetypeenum, gltexturetypeenums, gltexture_t::gltype, textypeinfo_t::gltype, height, i, gltexture_t::identifier, Image_CopyMux(), Image_MakeLinearColorsFromsRGB(), textypeinfo_t::inputbytesperpixel, gltexture_t::inputdatasize, gltexture_t::inputdepth, gltexture_t::inputheight, gltexture_t::inputwidth, textypeinfo_t::internalbytesperpixel, Mem_Alloc, Mem_ExpandableArray_AllocRecord(), Mem_Free, gltexture_t::miplevel, gltexture_t::miplevels, gltexture_t::modified_maxs, gltexture_t::modified_mins, NULL, gltexture_t::palette, gltexture_t::pool, R_GetTexTypeInfo(), R_PicmipForFlags(), R_UploadFullTexture(), viddef_t::renderpath, RENDERPATH_GL32, RENDERPATH_GLES2, gltexture_t::sides, size, client_static_t::state, viddef_t::support, Sys_Error(), tempmempool, TEXF_ALLOWUPDATES, TEXF_ALPHA, gltexture_t::texnum, texturearray, texturemempool, gltexture_t::texturetype, gltexture_t::textype, TEXTYPE_ALPHA, TEXTYPE_BGRA, TEXTYPE_COLORBUFFER, TEXTYPE_COLORBUFFER16F, TEXTYPE_COLORBUFFER32F, TEXTYPE_DXT1, TEXTYPE_DXT1A, TEXTYPE_DXT3, TEXTYPE_DXT5, TEXTYPE_PALETTE, TEXTYPE_RGBA, TEXTYPE_SHADOWMAP16_COMP, TEXTYPE_SHADOWMAP16_RAW, TEXTYPE_SHADOWMAP24_COMP, TEXTYPE_SHADOWMAP24_RAW, TEXTYPE_SRGB_BGRA, TEXTYPE_SRGB_DXT1, TEXTYPE_SRGB_DXT1A, TEXTYPE_SRGB_DXT3, TEXTYPE_SRGB_DXT5, TEXTYPE_SRGB_PALETTE, TEXTYPE_SRGB_RGBA, gltexture_t::tiledepth, gltexture_t::tileheight, gltexture_t::tilewidth, gltexture_t::updatecallback, gltexture_t::updatecallback_data, VectorClear, vid, and width.

Referenced by R_LoadTexture2D(), R_LoadTexture3D(), R_LoadTextureCubeMap(), and R_LoadTextureShadowMap2D().

R_TextureFlags()

int R_TextureFlags

(

rtexture_t *

rt

)

Definition at line 2280 of file gl_textures.c.

{
    return rt ? ((gltexture_t *)rt)->flags : 0;
}

Referenced by R_SetupShader_Surface().

R_TextureHeight()

int R_TextureHeight

(

rtexture_t *

rt

)

Definition at line 2275 of file gl_textures.c.

{
    return rt ? ((gltexture_t *)rt)->inputheight : 0;
}

Referenced by Draw_CachePic_Flags(), Mod_Q3BSP_LoadFaces(), and R_Shadow_SetShadowmapParametersForLight().

r_textures_devicelost()

static void r_textures_devicelost ( void )

static

Definition at line 681 of file gl_textures.c.

{
    int i, endindex;
    gltexture_t *glt;
    endindex = (int)Mem_ExpandableArray_IndexRange(&texturearray);
    for (i = 0;i < endindex;i++)
    {
        glt = (gltexture_t *) Mem_ExpandableArray_RecordAtIndex(&texturearray, i);
        if (!glt || !(glt->flags & TEXF_RENDERTARGET))
            continue;
        switch(vid.renderpath)
        {
        case RENDERPATH_GL32:
        case RENDERPATH_GLES2:
            break;
        }
    }
}

References gltexture_t::flags, i, int(), Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), viddef_t::renderpath, RENDERPATH_GL32, RENDERPATH_GLES2, TEXF_RENDERTARGET, texturearray, and vid.

Referenced by R_Textures_Init().

r_textures_devicerestored()

static void r_textures_devicerestored ( void )

static

Definition at line 700 of file gl_textures.c.

{
    int i, endindex;
    gltexture_t *glt;
    endindex = (int)Mem_ExpandableArray_IndexRange(&texturearray);
    for (i = 0;i < endindex;i++)
    {
        glt = (gltexture_t *) Mem_ExpandableArray_RecordAtIndex(&texturearray, i);
        if (!glt || !(glt->flags & TEXF_RENDERTARGET))
            continue;
        switch(vid.renderpath)
        {
        case RENDERPATH_GL32:
        case RENDERPATH_GLES2:
            break;
        }
    }
}

References gltexture_t::flags, i, int(), Mem_ExpandableArray_IndexRange(), Mem_ExpandableArray_RecordAtIndex(), viddef_t::renderpath, RENDERPATH_GL32, RENDERPATH_GLES2, TEXF_RENDERTARGET, texturearray, and vid.

Referenced by R_Textures_Init().

R_Textures_Frame()

void R_Textures_Frame

(

void

)

Definition at line 753 of file gl_textures.c.

{
#ifdef GL_TEXTURE_MAX_ANISOTROPY_EXT
    static int old_aniso = 0;
    static qbool first_time_aniso = true;
#endif
 
    // 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;
    }
 
#ifdef GL_TEXTURE_MAX_ANISOTROPY_EXT
    if (old_aniso != gl_texture_anisotropy.integer)
    {
        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);
 
        switch(vid.renderpath)
        {
        case RENDERPATH_GL32:
        case RENDERPATH_GLES2:
            // ignore the first difference, any textures loaded by now probably had the same aniso value
            if (first_time_aniso)
            {
                first_time_aniso = false;
                break;
            }
            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
                    }
                }
            }
            break;
        }
    }
#endif
}

References bound, gltexture_t::chain, CHECKGLERROR, colorconvertbuffer, Cvar_SetValueQuick(), gltexture_t::flags, GL_ActiveTexture(), gl_texture_anisotropy, GL_TEXTURE_MAX_ANISOTROPY_EXT, gltexturepool_t::gltchain, gltexturepoolchain, gltexturetypeenums, cvar_t::integer, viddef_t::max_anisotropy, Mem_Free, gltexturepool_t::next, NULL, R_Mesh_TexBound(), viddef_t::renderpath, RENDERPATH_GL32, RENDERPATH_GLES2, resizebuffer, resizebuffersize, TEXF_MIPMAP, gltexture_t::texnum, gltexture_t::texturetype, and vid.

Referenced by R_UpdateVariables().

R_Textures_Init()

void R_Textures_Init

(

void

)

Definition at line 720 of file gl_textures.c.

{
    Cmd_AddCommand(CF_CLIENT, "gl_texturemode", &GL_TextureMode_f, "set texture filtering mode (GL_NEAREST, GL_LINEAR, GL_LINEAR_MIPMAP_LINEAR, etc); an additional argument 'force' forces the texture mode even in cases where it may not be appropriate");
    Cmd_AddCommand(CF_CLIENT, "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_picmip_world);
    Cvar_RegisterVariable (&r_picmipworld);
    Cvar_RegisterVariable (&gl_picmip_sprites);
    Cvar_RegisterVariable (&r_picmipsprites);
    Cvar_RegisterVariable (&gl_picmip_other);
    Cvar_RegisterVariable (&gl_max_lightmapsize);
    Cvar_RegisterVariable (&r_lerpimages);
    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_texturecompression_sprites);
    Cvar_RegisterVariable (&r_texture_dds_load_alphamode);
    Cvar_RegisterVariable (&r_texture_dds_load_logfailure);
    Cvar_RegisterVariable (&r_texture_dds_swdecode);
 
    R_RegisterModule("R_Textures", r_textures_start, r_textures_shutdown, r_textures_newmap, r_textures_devicelost, r_textures_devicerestored);
}

References CF_CLIENT, Cmd_AddCommand(), Cvar_RegisterVariable(), gl_max_lightmapsize, gl_max_size, gl_picmip, gl_picmip_other, gl_picmip_sprites, gl_picmip_world, gl_texture_anisotropy, gl_texturecompression, gl_texturecompression_2d, gl_texturecompression_color, gl_texturecompression_gloss, gl_texturecompression_glow, gl_texturecompression_lightcubemaps, gl_texturecompression_normal, gl_texturecompression_q3bspdeluxemaps, gl_texturecompression_q3bsplightmaps, gl_texturecompression_reflectmask, gl_texturecompression_sky, gl_texturecompression_sprites, GL_TextureMode_f(), r_lerpimages, r_picmipsprites, r_picmipworld, R_RegisterModule(), r_texture_dds_load_alphamode, r_texture_dds_load_logfailure, r_texture_dds_swdecode, r_textures_devicelost(), r_textures_devicerestored(), r_textures_newmap(), r_textures_shutdown(), r_textures_start(), and R_TextureStats_f().

Referenced by Render_Init().

r_textures_newmap()

static void r_textures_newmap ( void )

static

Definition at line 677 of file gl_textures.c.

{
}

Referenced by R_Textures_Init().

r_textures_shutdown()

static void r_textures_shutdown ( void )

static

Definition at line 657 of file gl_textures.c.

{
    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);
}

References colorconvertbuffer, gltexturepoolchain, JPEG_CloseLibrary(), Mem_ExpandableArray_FreeArray(), Mem_FreePool, NULL, R_FreeTexturePool(), resizebuffer, resizebuffersize, texturearray, texturebuffer, and texturemempool.

Referenced by R_Textures_Init().

r_textures_start()

static void r_textures_start ( void )

static

Definition at line 634 of file gl_textures.c.

{
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        // LadyHavoc: allow any alignment
        CHECKGLERROR
        qglPixelStorei(GL_UNPACK_ALIGNMENT, 1);CHECKGLERROR
        qglPixelStorei(GL_PACK_ALIGNMENT, 1);CHECKGLERROR
        break;
    }
 
    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);
    if (! PNG_OpenLibrary ())
        Cvar_SetValueQuick (&scr_screenshot_png, 0);
}

References CHECKGLERROR, Cvar_SetValueQuick(), GL_PACK_ALIGNMENT, GL_UNPACK_ALIGNMENT, JPEG_OpenLibrary(), Mem_AllocPool, Mem_ExpandableArray_NewArray(), NULL, PNG_OpenLibrary(), viddef_t::renderpath, RENDERPATH_GL32, RENDERPATH_GLES2, scr_screenshot_jpeg, scr_screenshot_png, texturearray, texturemempool, and vid.

Referenced by R_Textures_Init().

R_TextureStats_f()

static void R_TextureStats_f ( cmd_state_t * cmd )

static

Definition at line 629 of file gl_textures.c.

{
    R_TextureStats_Print(true, true, true);
}

References R_TextureStats_Print().

Referenced by R_Textures_Init().

R_TextureStats_Print()

void R_TextureStats_Print	(	qbool	printeach,
		qbool	printpool,
		qbool	printtotal )

Definition at line 582 of file gl_textures.c.

{
    int glsize;
    int isloaded;
    int pooltotal = 0, pooltotalt = 0, pooltotalp = 0, poolloaded = 0, poolloadedt = 0, poolloadedp = 0;
    int sumtotal = 0, sumtotalt = 0, sumtotalp = 0, sumloaded = 0, sumloadedt = 0, sumloadedp = 0;
    gltexture_t *glt;
    gltexturepool_t *pool;
    if (printeach)
        Con_Print("glsize input loaded mip alpha name\n");
    for (pool = gltexturepoolchain;pool;pool = pool->next)
    {
        pooltotal = 0;
        pooltotalt = 0;
        pooltotalp = 0;
        poolloaded = 0;
        poolloadedt = 0;
        poolloadedp = 0;
        for (glt = pool->gltchain;glt;glt = glt->chain)
        {
            glsize = R_CalcTexelDataSize(glt);
            isloaded = glt->texnum != 0 || glt->renderbuffernum != 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 %-24s %s %s %s %s\n", isloaded ? '[' : ' ', (glsize + 1023) / 1024, isloaded ? ']' : ' ', glt->inputtexels ? '[' : ' ', (glt->inputdatasize + 1023) / 1024, glt->inputtexels ? ']' : ' ', glt->textype->name, 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);
}

References gltexture_t::chain, Con_Print(), Con_Printf(), gltexture_t::flags, gltexturepool_t::gltchain, gltexturepoolchain, gltexture_t::identifier, gltexture_t::inputdatasize, gltexture_t::inputtexels, textypeinfo_t::name, gltexturepool_t::next, R_CalcTexelDataSize(), gltexture_t::renderbuffernum, TEXF_ALPHA, TEXF_MIPMAP, gltexture_t::texnum, and gltexture_t::textype.

Referenced by R_TextureStats_f().

R_TextureWidth()

int R_TextureWidth

(

rtexture_t *

rt

)

Definition at line 2270 of file gl_textures.c.

{
    return rt ? ((gltexture_t *)rt)->inputwidth : 0;
}

Referenced by Draw_CachePic_Flags(), Mod_Q3BSP_LoadFaces(), and R_Shadow_SetShadowmapParametersForLight().

R_UpdateDynamicTexture()

static void R_UpdateDynamicTexture ( gltexture_t * glt )

static

Definition at line 337 of file gl_textures.c.

                                                     {
    glt->dirty = false;
    if( glt->updatecallback ) {
        glt->updatecallback( (rtexture_t*) glt, glt->updatecallback_data );
    }
}

References gltexture_t::dirty, and gltexture_t::updatecallback.

Referenced by R_RealGetTexture().

R_UpdateTexture()

void R_UpdateTexture	(	rtexture_t *	rt,
		const unsigned char *	data,
		int	x,
		int	y,
		int	z,
		int	width,
		int	height,
		int	depth,
		int	combine )

Definition at line 2285 of file gl_textures.c.

{
    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)
    {
        Con_DPrintf("R_UpdateTexture: texture %p \"%s\" in pool %p has not been uploaded yet\n", (void *)glt, glt->identifier, (void *)glt->pool);
        return;
    }
    // update part of the texture
    if (glt->bufferpixels)
    {
        size_t j, bpp = glt->bytesperpixel;
 
        // depth and sides are not fully implemented here - can still do full updates but not partial.
        if (glt->inputdepth != 1 || glt->sides != 1)
            Host_Error("R_UpdateTexture on buffered texture that is not 2D\n");
        if (x < 0 || y < 0 || z < 0 || glt->tilewidth < x + width || glt->tileheight < y + height || glt->tiledepth < z + depth)
            Host_Error("R_UpdateTexture on buffered texture with out of bounds coordinates (%i %i %i to %i %i %i is not within 0 0 0 to %i %i %i)", x, y, z, x + width, y + height, z + depth, glt->tilewidth, glt->tileheight, glt->tiledepth);
 
        for (j = 0; j < (size_t)height; j++)
            memcpy(glt->bufferpixels + ((y + j) * glt->tilewidth + x) * bpp, data + j * width * bpp, width * bpp);
 
        switch(combine)
        {
        case 0:
            // immediately update the part of the texture, no combining
            R_UploadPartialTexture(glt, data, x, y, z, width, height, depth);
            break;
        case 1:
            // keep track of the region that is modified, decide later how big the partial update area is
            if (glt->buffermodified)
            {
                glt->modified_mins[0] = min(glt->modified_mins[0], x);
                glt->modified_mins[1] = min(glt->modified_mins[1], y);
                glt->modified_mins[2] = min(glt->modified_mins[2], z);
                glt->modified_maxs[0] = max(glt->modified_maxs[0], x + width);
                glt->modified_maxs[1] = max(glt->modified_maxs[1], y + height);
                glt->modified_maxs[2] = max(glt->modified_maxs[2], z + depth);
            }
            else
            {
                glt->buffermodified = true;
                glt->modified_mins[0] = x;
                glt->modified_mins[1] = y;
                glt->modified_mins[2] = z;
                glt->modified_maxs[0] = x + width;
                glt->modified_maxs[1] = y + height;
                glt->modified_maxs[2] = z + depth;
            }
            glt->dirty = true;
            break;
        default:
        case 2:
            // mark the entire texture as dirty, it will be uploaded later
            glt->buffermodified = true;
            glt->modified_mins[0] = 0;
            glt->modified_mins[1] = 0;
            glt->modified_mins[2] = 0;
            glt->modified_maxs[0] = glt->tilewidth;
            glt->modified_maxs[1] = glt->tileheight;
            glt->modified_maxs[2] = glt->tiledepth;
            glt->dirty = true;
            break;
        }
    }
    else
        R_UploadFullTexture(glt, data);
}

References gltexture_t::buffermodified, gltexture_t::bufferpixels, gltexture_t::bytesperpixel, Con_DPrintf(), data, depth, gltexture_t::dirty, height, Host_Error(), gltexture_t::identifier, gltexture_t::inputdepth, max, min, gltexture_t::modified_maxs, gltexture_t::modified_mins, NULL, R_UploadFullTexture(), R_UploadPartialTexture(), gltexture_t::sides, gltexture_t::texnum, gltexture_t::tiledepth, gltexture_t::tileheight, gltexture_t::tilewidth, width, x, y, and z.

Referenced by Draw_NewPic(), R_BuildFogTexture(), R_BuildLightMap(), R_Shadow_BounceGrid_ConvertPixelsAndUpload(), and R_UpdateVariables().

R_UploadFullTexture()

static void R_UploadFullTexture ( gltexture_t * glt, const unsigned char * data )

static

Definition at line 965 of file gl_textures.c.

{
    int i, mip = 0, width, height, depth;
    GLint oldbindtexnum = 0;
    const unsigned char *prevbuffer;
    prevbuffer = data;
 
    // error out if a stretch is needed on special texture types
    if (glt->texturetype != GLTEXTURETYPE_2D && (glt->tilewidth != glt->inputwidth || glt->tileheight != glt->inputheight || glt->tiledepth != glt->inputdepth))
        Sys_Error("R_UploadFullTexture \"%s\": stretch uploads allowed only on 2D textures\n", glt->identifier);
 
    // when picmip or maxsize is applied, we scale up to a power of 2 multiple
    // of the target size and then use the mipmap reduction function to get
    // high quality supersampled results
    for (width  = glt->tilewidth;width  < glt->inputwidth ;width  <<= 1);
    for (height = glt->tileheight;height < glt->inputheight;height <<= 1);
    for (depth  = glt->tiledepth;depth  < glt->inputdepth ;depth  <<= 1);
 
    if (prevbuffer == NULL)
    {
        width = glt->tilewidth;
        height = glt->tileheight;
        depth = glt->tiledepth;
//      R_MakeResizeBufferBigger(width * height * depth * glt->sides * glt->bytesperpixel);
//      memset(resizebuffer, 0, width * height * depth * glt->sides * 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
            R_MakeResizeBufferBigger(width * height * depth * glt->sides * glt->bytesperpixel);
            Image_Copy8bitBGRA(prevbuffer, colorconvertbuffer, glt->inputwidth * glt->inputheight * glt->inputdepth * glt->sides, glt->palette);
            prevbuffer = colorconvertbuffer;
        }
        if (glt->flags & TEXF_RGBMULTIPLYBYALPHA)
        {
            // multiply RGB channels by A channel before uploading
            int alpha;
            R_MakeResizeBufferBigger(width * height * depth * glt->sides * glt->bytesperpixel);
            for (i = 0;i < glt->inputwidth*glt->inputheight*glt->inputdepth*4;i += 4)
            {
                alpha = prevbuffer[i+3];
                colorconvertbuffer[i] = (prevbuffer[i] * alpha) >> 8;
                colorconvertbuffer[i+1] = (prevbuffer[i+1] * alpha) >> 8;
                colorconvertbuffer[i+2] = (prevbuffer[i+2] * alpha) >> 8;
                colorconvertbuffer[i+3] = alpha;
            }
            prevbuffer = colorconvertbuffer;
        }
        // scale up to a power of 2 size (if appropriate)
        if (glt->inputwidth != width || glt->inputheight != height || glt->inputdepth != depth)
        {
            R_MakeResizeBufferBigger(width * height * depth * glt->sides * glt->bytesperpixel);
            Image_Resample32(prevbuffer, glt->inputwidth, glt->inputheight, glt->inputdepth, resizebuffer, width, height, depth, r_lerpimages.integer);
            prevbuffer = resizebuffer;
        }
        // apply mipmap reduction algorithm to get down to picmip/max_size
        while (width > glt->tilewidth || height > glt->tileheight || depth > glt->tiledepth)
        {
            R_MakeResizeBufferBigger(width * height * depth * glt->sides * glt->bytesperpixel);
            Image_MipReduce32(prevbuffer, resizebuffer, &width, &height, &depth, glt->tilewidth, glt->tileheight, glt->tiledepth);
            prevbuffer = resizebuffer;
        }
    }
 
    // do the appropriate upload type...
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        if (glt->texnum) // not renderbuffers
        {
            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
 
#ifndef USE_GLES2
            if (gl_texturecompression.integer >= 2)
                qglHint(GL_TEXTURE_COMPRESSION_HINT, GL_NICEST);
            else
                qglHint(GL_TEXTURE_COMPRESSION_HINT, GL_FASTEST);
            CHECKGLERROR
#endif
            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)
                {
                    while (width > 1 || height > 1 || depth > 1)
                    {
                        R_MakeResizeBufferBigger(width * height * depth * glt->sides * glt->bytesperpixel);
                        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:
#ifndef USE_GLES2
                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)
                    {
                        R_MakeResizeBufferBigger(width * height * depth * glt->sides * glt->bytesperpixel);
                        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
                    }
                }
#endif
                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)
                    {
                        R_MakeResizeBufferBigger(width * height * depth * glt->sides * glt->bytesperpixel);
                        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)
                    {
                        R_MakeResizeBufferBigger(width * height * depth * glt->sides * glt->bytesperpixel);
                        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)
                        {
                            R_MakeResizeBufferBigger(width * height * depth * glt->sides * glt->bytesperpixel);
                            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;
            }
            GL_SetupTextureParameters(glt->flags, glt->textype->textype, glt->texturetype);
            qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR
        }
        break;
    }
}

References alpha, gltexture_t::bytesperpixel, CHECKGLERROR, colorconvertbuffer, cubemapside, data, depth, gltexture_t::flags, GL_ActiveTexture(), GL_FASTEST, GL_NICEST, GL_SetupTextureParameters(), GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_COMPRESSION_HINT, gl_texturecompression, gltexture_t::glformat, gltexture_t::glinternalformat, GLTEXTURETYPE_2D, GLTEXTURETYPE_3D, GLTEXTURETYPE_CUBEMAP, gltexturetypeenums, gltexture_t::gltype, height, i, gltexture_t::identifier, Image_Copy8bitBGRA(), Image_MipReduce32(), Image_Resample32(), textypeinfo_t::inputbytesperpixel, gltexture_t::inputdepth, gltexture_t::inputheight, gltexture_t::inputwidth, cvar_t::integer, NULL, gltexture_t::palette, r_lerpimages, R_MakeResizeBufferBigger(), R_Mesh_TexBound(), viddef_t::renderpath, RENDERPATH_GL32, RENDERPATH_GLES2, resizebuffer, gltexture_t::sides, Sys_Error(), TEXF_MIPMAP, TEXF_RGBMULTIPLYBYALPHA, gltexture_t::texnum, texturebuffer, gltexture_t::texturetype, gltexture_t::textype, textypeinfo_t::textype, TEXTYPE_PALETTE, gltexture_t::tiledepth, gltexture_t::tileheight, gltexture_t::tilewidth, vid, and width.

Referenced by R_ClearTexture(), R_RealGetTexture(), R_SetupTexture(), and R_UpdateTexture().

R_UploadPartialTexture()

static void R_UploadPartialTexture ( gltexture_t * glt, const unsigned char * data, int fragx, int fragy, int fragz, int fragwidth, int fragheight, int fragdepth )

static

Definition at line 928 of file gl_textures.c.

{
    if (data == NULL)
        Sys_Error("R_UploadPartialTexture \"%s\": partial update with NULL pixels", glt->identifier);
 
    if (glt->texturetype != GLTEXTURETYPE_2D)
        Sys_Error("R_UploadPartialTexture \"%s\": partial update of type other than 2D", glt->identifier);
 
    if (glt->textype->textype == TEXTYPE_PALETTE)
        Sys_Error("R_UploadPartialTexture \"%s\": partial update of paletted texture", glt->identifier);
 
    if (glt->flags & (TEXF_MIPMAP | TEXF_PICMIP))
        Sys_Error("R_UploadPartialTexture \"%s\": partial update not supported with MIPMAP or PICMIP flags", glt->identifier);
 
    if (glt->inputwidth != glt->tilewidth || glt->inputheight != glt->tileheight || glt->tiledepth != 1)
        Sys_Error("R_UploadPartialTexture \"%s\": partial update not supported with stretched or special textures", glt->identifier);
 
    // update a portion of the image
 
    switch(vid.renderpath)
    {
    case RENDERPATH_GL32:
    case RENDERPATH_GLES2:
        {
            int oldbindtexnum;
            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
            qglTexSubImage2D(GL_TEXTURE_2D, 0, fragx, fragy, fragwidth, fragheight, glt->glformat, glt->gltype, data);CHECKGLERROR
            qglBindTexture(gltexturetypeenums[glt->texturetype], oldbindtexnum);CHECKGLERROR
        }
        break;
    }
}

References CHECKGLERROR, data, gltexture_t::flags, GL_ActiveTexture(), GL_TEXTURE_2D, gltexture_t::glformat, GLTEXTURETYPE_2D, gltexturetypeenums, gltexture_t::gltype, gltexture_t::identifier, gltexture_t::inputheight, gltexture_t::inputwidth, NULL, R_Mesh_TexBound(), viddef_t::renderpath, RENDERPATH_GL32, RENDERPATH_GLES2, Sys_Error(), TEXF_MIPMAP, TEXF_PICMIP, gltexture_t::texnum, gltexture_t::texturetype, gltexture_t::textype, textypeinfo_t::textype, TEXTYPE_PALETTE, gltexture_t::tiledepth, gltexture_t::tileheight, gltexture_t::tilewidth, and vid.

Referenced by R_RealGetTexture(), and R_UpdateTexture().

Variable Documentation

colorconvertbuffer

unsigned char * colorconvertbuffer

static

Definition at line 251 of file gl_textures.c.

Referenced by R_MakeResizeBufferBigger(), R_Textures_Frame(), r_textures_shutdown(), and R_UploadFullTexture().

cubemapside

int cubemapside[6]

static

Initial value:

=
{
    GL_TEXTURE_CUBE_MAP_POSITIVE_X,
    GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
    GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
    GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
    GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
    GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
}

Definition at line 168 of file gl_textures.c.

{
    GL_TEXTURE_CUBE_MAP_POSITIVE_X,
    GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
    GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
    GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
    GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
    GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
};

Referenced by R_UploadFullTexture().

gl_filter_force

qbool gl_filter_force = false

Definition at line 53 of file gl_textures.c.

Referenced by GL_SetupTextureParameters(), and GL_TextureMode_f().

gl_filter_mag

int gl_filter_mag = GL_LINEAR

Definition at line 55 of file gl_textures.c.

Referenced by GL_SetupTextureParameters(), and GL_TextureMode_f().

gl_filter_min

int gl_filter_min = GL_LINEAR_MIPMAP_LINEAR

Definition at line 54 of file gl_textures.c.

Referenced by GL_SetupTextureParameters(), and GL_TextureMode_f().

gl_max_lightmapsize

cvar_t gl_max_lightmapsize = {CF_CLIENT | CF_ARCHIVE, "gl_max_lightmapsize", "512", "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)"}

Definition at line 28 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_max_lightmapsize", "512", "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)"};

Referenced by Mod_Q1BSP_LoadFaces(), Mod_VBSP_LoadFaces(), and R_Textures_Init().

gl_max_size

cvar_t gl_max_size = {CF_CLIENT | CF_ARCHIVE, "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)"}

Definition at line 27 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "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)"};

Referenced by GL_Texture_CalcImageSize(), and R_Textures_Init().

gl_picmip

cvar_t gl_picmip = {CF_CLIENT | CF_ARCHIVE, "gl_picmip", "0", "reduces resolution of textures by powers of 2, for example 1 will halve width/height, reducing texture memory usage by 75%"}

Definition at line 29 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_picmip", "0", "reduces resolution of textures by powers of 2, for example 1 will halve width/height, reducing texture memory usage by 75%"};

Referenced by M_Menu_Video_AdjustSliders(), M_Video_Draw(), R_PicmipForFlags(), and R_Textures_Init().

gl_picmip_other

cvar_t gl_picmip_other = {CF_CLIENT | CF_ARCHIVE, "gl_picmip_other", "0", "extra picmip level for other textures (may be negative, which will then reduce gl_picmip for these)"}

Definition at line 34 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_picmip_other", "0", "extra picmip level for other textures (may be negative, which will then reduce gl_picmip for these)"};

Referenced by R_PicmipForFlags(), and R_Textures_Init().

gl_picmip_sprites

cvar_t gl_picmip_sprites = {CF_CLIENT | CF_ARCHIVE, "gl_picmip_sprites", "0", "extra picmip level for sprite textures (may be negative, which will then reduce gl_picmip for these)"}

Definition at line 32 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_picmip_sprites", "0", "extra picmip level for sprite textures (may be negative, which will then reduce gl_picmip for these)"};

Referenced by R_PicmipForFlags(), and R_Textures_Init().

gl_picmip_world

cvar_t gl_picmip_world = {CF_CLIENT | CF_ARCHIVE, "gl_picmip_world", "0", "extra picmip level for world textures (may be negative, which will then reduce gl_picmip for these)"}

Definition at line 30 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_picmip_world", "0", "extra picmip level for world textures (may be negative, which will then reduce gl_picmip for these)"};

Referenced by R_PicmipForFlags(), and R_Textures_Init().

gl_texture_anisotropy

cvar_t gl_texture_anisotropy = {CF_CLIENT | CF_ARCHIVE, "gl_texture_anisotropy", "1", "anisotropic filtering quality (if supported by hardware), 1 sample (no anisotropy) and 8 sample (8 tap anisotropy) are recommended values"}

Definition at line 36 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_texture_anisotropy", "1", "anisotropic filtering quality (if supported by hardware), 1 sample (no anisotropy) and 8 sample (8 tap anisotropy) are recommended values"};

Referenced by GL_SetupTextureParameters(), M_Menu_Video_AdjustSliders(), M_Video_Draw(), R_Textures_Frame(), and R_Textures_Init().

gl_texturecompression

cvar_t gl_texturecompression = {CF_CLIENT | CF_ARCHIVE, "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"}

Definition at line 37 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "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"};

Referenced by Draw_CachePic_Flags(), M_Menu_Video_AdjustSliders(), M_Video_Draw(), Mod_Sprite_SharedSetup(), R_LoadCubemap(), R_SkinFrame_LoadExternal_SkinFrame(), R_Textures_Init(), and R_UploadFullTexture().

gl_texturecompression_2d

cvar_t gl_texturecompression_2d = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_2d", "0", "whether to compress 2d (hud/menu) textures other than the font"}

Definition at line 42 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_2d", "0", "whether to compress 2d (hud/menu) textures other than the font"};

Referenced by Draw_CachePic_Flags(), and R_Textures_Init().

gl_texturecompression_color

cvar_t gl_texturecompression_color = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_color", "1", "whether to compress colormap (diffuse) textures"}

Definition at line 38 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_color", "1", "whether to compress colormap (diffuse) textures"};

Referenced by GL_Setup(), R_SkinFrame_LoadExternal_SkinFrame(), and R_Textures_Init().

gl_texturecompression_gloss

cvar_t gl_texturecompression_gloss = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_gloss", "1", "whether to compress glossmap (specular) textures"}

Definition at line 40 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_gloss", "1", "whether to compress glossmap (specular) textures"};

Referenced by R_SkinFrame_LoadExternal_SkinFrame(), and R_Textures_Init().

gl_texturecompression_glow

cvar_t gl_texturecompression_glow = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_glow", "1", "whether to compress glowmap (luma) textures"}

Definition at line 41 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_glow", "1", "whether to compress glowmap (luma) textures"};

Referenced by R_SkinFrame_LoadExternal_SkinFrame(), and R_Textures_Init().

gl_texturecompression_lightcubemaps

cvar_t gl_texturecompression_lightcubemaps = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_lightcubemaps", "1", "whether to compress light cubemaps (spotlights and other light projection images)"}

Definition at line 46 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_lightcubemaps", "1", "whether to compress light cubemaps (spotlights and other light projection images)"};

Referenced by R_LoadCubemap(), and R_Textures_Init().

gl_texturecompression_normal

cvar_t gl_texturecompression_normal = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_normal", "0", "whether to compress normalmap (normalmap) textures"}

Definition at line 39 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_normal", "0", "whether to compress normalmap (normalmap) textures"};

Referenced by R_SkinFrame_LoadExternal_SkinFrame(), and R_Textures_Init().

gl_texturecompression_q3bspdeluxemaps

cvar_t gl_texturecompression_q3bspdeluxemaps = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_q3bspdeluxemaps", "0", "whether to compress deluxemaps in q3bsp format levels (only levels compiled with q3map2 -deluxe have these)"}

Definition at line 44 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_q3bspdeluxemaps", "0", "whether to compress deluxemaps in q3bsp format levels (only levels compiled with q3map2 -deluxe have these)"};

Referenced by Mod_Q3BSP_LoadLightmaps(), and R_Textures_Init().

gl_texturecompression_q3bsplightmaps

cvar_t gl_texturecompression_q3bsplightmaps = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_q3bsplightmaps", "0", "whether to compress lightmaps in q3bsp format levels"}

Definition at line 43 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_q3bsplightmaps", "0", "whether to compress lightmaps in q3bsp format levels"};

Referenced by Mod_Q3BSP_LoadLightmaps(), and R_Textures_Init().

gl_texturecompression_reflectmask

cvar_t gl_texturecompression_reflectmask = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_reflectmask", "1", "whether to compress reflection cubemap masks (mask of which areas of the texture should reflect the generic shiny cubemap)"}

Definition at line 47 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_reflectmask", "1", "whether to compress reflection cubemap masks (mask of which areas of the texture should reflect the generic shiny cubemap)"};

Referenced by R_SkinFrame_LoadExternal_SkinFrame(), and R_Textures_Init().

gl_texturecompression_sky

cvar_t gl_texturecompression_sky = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_sky", "0", "whether to compress sky textures"}

Definition at line 45 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_sky", "0", "whether to compress sky textures"};

Referenced by R_LoadSkyBox(), and R_Textures_Init().

gl_texturecompression_sprites

cvar_t gl_texturecompression_sprites = {CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_sprites", "1", "whether to compress sprites"}

Definition at line 48 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "gl_texturecompression_sprites", "1", "whether to compress sprites"};

Referenced by Mod_Sprite_SharedSetup(), and R_Textures_Init().

gltexturepoolchain

gltexturepool_t* gltexturepoolchain = NULL

static

Definition at line 249 of file gl_textures.c.

Referenced by GL_TextureMode_f(), R_AllocTexturePool(), R_FreeTexturePool(), R_Textures_Frame(), r_textures_shutdown(), and R_TextureStats_Print().

gltexturetypedimensions

int gltexturetypedimensions[GLTEXTURETYPE_TOTAL] = {2, 3, 2}

static

Definition at line 166 of file gl_textures.c.

{2, 3, 2};

Referenced by GL_SetupTextureParameters().

gltexturetypeenums

int gltexturetypeenums[GLTEXTURETYPE_TOTAL] = {GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP}

static

Definition at line 164 of file gl_textures.c.

{GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP};

Referenced by GL_SetupTextureParameters(), GL_TextureMode_f(), R_LoadTextureDDSFile(), R_SaveTextureDDSFile(), R_SetupTexture(), R_Textures_Frame(), R_UploadFullTexture(), and R_UploadPartialTexture().

modes

glmode_t modes[6]

static

Initial value:

=
{
    {"GL_NEAREST", GL_NEAREST, GL_NEAREST},
    {"GL_LINEAR", GL_LINEAR, GL_LINEAR},
    {"GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST},
    {"GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR},
    {"GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST},
    {"GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR}
}

Definition at line 432 of file gl_textures.c.

{
    {"GL_NEAREST", GL_NEAREST, GL_NEAREST},
    {"GL_LINEAR", GL_LINEAR, GL_LINEAR},
    {"GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST},
    {"GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR},
    {"GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST},
    {"GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR}
};

Referenced by GL_TextureMode_f(), VID_ListModes(), and VID_SortModes().

r_lerpimages

cvar_t r_lerpimages = {CF_CLIENT | CF_ARCHIVE, "r_lerpimages", "1", "bilinear filters images when scaling them up to power of 2 size (mode 1), looks better than glquake (mode 0)"}

Definition at line 35 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "r_lerpimages", "1", "bilinear filters images when scaling them up to power of 2 size (mode 1), looks better than glquake (mode 0)"};

Referenced by R_Textures_Init(), and R_UploadFullTexture().

r_picmipsprites

cvar_t r_picmipsprites = {CF_CLIENT | CF_ARCHIVE, "r_picmipsprites", "1", "make gl_picmip affect sprites too (saves some graphics memory in sprite heavy games) (setting this to 0 is a shorthand for gl_picmip_sprites -9999999)"}

Definition at line 33 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "r_picmipsprites", "1", "make gl_picmip affect sprites too (saves some graphics memory in sprite heavy games) (setting this to 0 is a shorthand for gl_picmip_sprites -9999999)"};

Referenced by R_PicmipForFlags(), and R_Textures_Init().

r_picmipworld

cvar_t r_picmipworld = {CF_CLIENT | CF_ARCHIVE, "r_picmipworld", "1", "whether gl_picmip shall apply to world textures too (setting this to 0 is a shorthand for gl_picmip_world -9999999)"}

Definition at line 31 of file gl_textures.c.

{CF_CLIENT | CF_ARCHIVE, "r_picmipworld", "1", "whether gl_picmip shall apply to world textures too (setting this to 0 is a shorthand for gl_picmip_world -9999999)"};

Referenced by R_PicmipForFlags(), and R_Textures_Init().

r_texture_dds_load_alphamode

cvar_t r_texture_dds_load_alphamode = {CF_CLIENT, "r_texture_dds_load_alphamode", "1", "0: trust DDPF_ALPHAPIXELS flag, 1: texture format and brute force search if ambiguous, 2: texture format only"}

Definition at line 49 of file gl_textures.c.

{CF_CLIENT, "r_texture_dds_load_alphamode", "1", "0: trust DDPF_ALPHAPIXELS flag, 1: texture format and brute force search if ambiguous, 2: texture format only"};

Referenced by R_LoadTextureDDSFile(), and R_Textures_Init().

r_texture_dds_load_logfailure

cvar_t r_texture_dds_load_logfailure = {CF_CLIENT, "r_texture_dds_load_logfailure", "0", "log missing DDS textures to ddstexturefailures.log, 0: done log, 1: log with no optional textures (_norm, glow etc.). 2: log all"}

Definition at line 50 of file gl_textures.c.

{CF_CLIENT, "r_texture_dds_load_logfailure", "0", "log missing DDS textures to ddstexturefailures.log, 0: done log, 1: log with no optional textures (_norm, glow etc.). 2: log all"};

Referenced by R_LoadTextureDDSFile(), and R_Textures_Init().

r_texture_dds_swdecode

cvar_t r_texture_dds_swdecode = {CF_CLIENT, "r_texture_dds_swdecode", "0", "0: don't software decode DDS, 1: software decode DDS if unsupported, 2: always software decode DDS"}

Definition at line 51 of file gl_textures.c.

{CF_CLIENT, "r_texture_dds_swdecode", "0", "0: don't software decode DDS, 1: software decode DDS if unsupported, 2: always software decode DDS"};

Referenced by R_LoadTextureDDSFile(), and R_Textures_Init().

resizebuffer

unsigned char* resizebuffer = NULL

static

Definition at line 251 of file gl_textures.c.

Referenced by R_MakeResizeBufferBigger(), R_Textures_Frame(), r_textures_shutdown(), and R_UploadFullTexture().

resizebuffersize

int resizebuffersize = 0

static

Definition at line 252 of file gl_textures.c.

Referenced by R_MakeResizeBufferBigger(), R_Textures_Frame(), and r_textures_shutdown().

texturearray

memexpandablearray_t texturearray

static

Definition at line 59 of file gl_textures.c.

Referenced by R_FreeTexture(), R_LoadTextureDDSFile(), R_LoadTextureRenderBuffer(), R_SetupTexture(), r_textures_devicelost(), r_textures_devicerestored(), r_textures_shutdown(), and r_textures_start().

texturebuffer

const unsigned char* texturebuffer

static

Definition at line 253 of file gl_textures.c.

Referenced by r_textures_shutdown(), and R_UploadFullTexture().

texturemempool

mempool_t* texturemempool

static

Definition at line 58 of file gl_textures.c.

Referenced by R_AllocTexturePool(), R_MakeResizeBufferBigger(), R_SetupTexture(), r_textures_shutdown(), and r_textures_start().

textype_alpha

textypeinfo_t textype_alpha = {"alpha", TEXTYPE_ALPHA , 1, 4, 4.0f, GL_ALPHA , GL_ALPHA , GL_UNSIGNED_BYTE }

static

Definition at line 124 of file gl_textures.c.

{"alpha",                    TEXTYPE_ALPHA         ,  1,  4,  4.0f, GL_ALPHA                              , GL_ALPHA          , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_bgra

textypeinfo_t textype_bgra = {"bgra", TEXTYPE_BGRA , 4, 4, 4.0f, GL_RGB , GL_BGRA , GL_UNSIGNED_BYTE }

static

Definition at line 131 of file gl_textures.c.

{"bgra",                     TEXTYPE_BGRA          ,  4,  4,  4.0f, GL_RGB                                , GL_BGRA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_bgra_alpha

textypeinfo_t textype_bgra_alpha = {"bgra_alpha", TEXTYPE_BGRA , 4, 4, 4.0f, GL_RGBA , GL_BGRA , GL_UNSIGNED_BYTE }

static

Definition at line 132 of file gl_textures.c.

{"bgra_alpha",               TEXTYPE_BGRA          ,  4,  4,  4.0f, GL_RGBA                               , GL_BGRA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_bgra_alpha_compress

textypeinfo_t textype_bgra_alpha_compress = {"bgra_alpha_compress", TEXTYPE_BGRA , 4, 4, 1.0f, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT , GL_BGRA , GL_UNSIGNED_BYTE }

static

Definition at line 134 of file gl_textures.c.

{"bgra_alpha_compress",      TEXTYPE_BGRA          ,  4,  4,  1.0f, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT      , GL_BGRA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_bgra_compress

textypeinfo_t textype_bgra_compress = {"bgra_compress", TEXTYPE_BGRA , 4, 4, 0.5f, GL_COMPRESSED_RGB_S3TC_DXT1_EXT , GL_BGRA , GL_UNSIGNED_BYTE }

static

Definition at line 133 of file gl_textures.c.

{"bgra_compress",            TEXTYPE_BGRA          ,  4,  4,  0.5f, GL_COMPRESSED_RGB_S3TC_DXT1_EXT       , GL_BGRA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_colorbuffer

textypeinfo_t textype_colorbuffer = {"colorbuffer", TEXTYPE_COLORBUFFER , 4, 4, 4.0f, GL_RGBA , GL_BGRA , GL_UNSIGNED_BYTE }

static

Definition at line 119 of file gl_textures.c.

{"colorbuffer",              TEXTYPE_COLORBUFFER          ,  4,  4,  4.0f, GL_RGBA                           , GL_BGRA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_colorbuffer16f

textypeinfo_t textype_colorbuffer16f = {"colorbuffer16f", TEXTYPE_COLORBUFFER16F , 8, 8, 8.0f, GL_RGBA16F , GL_RGBA , GL_HALF_FLOAT }

static

Definition at line 120 of file gl_textures.c.

{"colorbuffer16f",           TEXTYPE_COLORBUFFER16F       ,  8,  8,  8.0f, GL_RGBA16F                        , GL_RGBA           , GL_HALF_FLOAT    };

Referenced by R_GetTexTypeInfo().

textype_colorbuffer32f

textypeinfo_t textype_colorbuffer32f = {"colorbuffer32f", TEXTYPE_COLORBUFFER32F , 16, 16, 16.0f, GL_RGBA32F , GL_RGBA , GL_FLOAT }

static

Definition at line 121 of file gl_textures.c.

{"colorbuffer32f",           TEXTYPE_COLORBUFFER32F       , 16, 16, 16.0f, GL_RGBA32F                        , GL_RGBA           , GL_FLOAT         };

Referenced by R_GetTexTypeInfo().

textype_depth16

textypeinfo_t textype_depth16 = {"depth16", TEXTYPE_DEPTHBUFFER16 , 2, 2, 2.0f, GL_DEPTH_COMPONENT16 , GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT}

static

Definition at line 116 of file gl_textures.c.

{"depth16",                  TEXTYPE_DEPTHBUFFER16        ,  2,  2,  2.0f, GL_DEPTH_COMPONENT16              , GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT};

Referenced by R_GetTexTypeInfo().

textype_depth24

textypeinfo_t textype_depth24 = {"depth24", TEXTYPE_DEPTHBUFFER24 , 4, 4, 4.0f, GL_DEPTH_COMPONENT24 , GL_DEPTH_COMPONENT, GL_UNSIGNED_INT }

static

Definition at line 117 of file gl_textures.c.

{"depth24",                  TEXTYPE_DEPTHBUFFER24        ,  4,  4,  4.0f, GL_DEPTH_COMPONENT24              , GL_DEPTH_COMPONENT, GL_UNSIGNED_INT  };

Referenced by R_GetTexTypeInfo().

textype_depth24stencil8

textypeinfo_t textype_depth24stencil8 = {"depth24stencil8", TEXTYPE_DEPTHBUFFER24STENCIL8, 4, 4, 4.0f, GL_DEPTH24_STENCIL8 , GL_DEPTH_STENCIL , GL_UNSIGNED_INT_24_8}

static

Definition at line 118 of file gl_textures.c.

{"depth24stencil8",          TEXTYPE_DEPTHBUFFER24STENCIL8,  4,  4,  4.0f, GL_DEPTH24_STENCIL8               , GL_DEPTH_STENCIL  , GL_UNSIGNED_INT_24_8};

Referenced by R_GetTexTypeInfo().

textype_dxt1

textypeinfo_t textype_dxt1 = {"dxt1", TEXTYPE_DXT1 , 4, 0, 0.5f, GL_COMPRESSED_RGB_S3TC_DXT1_EXT , 0 , 0 }

static

Definition at line 135 of file gl_textures.c.

{"dxt1",                     TEXTYPE_DXT1          ,  4,  0,  0.5f, GL_COMPRESSED_RGB_S3TC_DXT1_EXT       , 0                 , 0                };

Referenced by R_GetTexTypeInfo().

textype_dxt1a

textypeinfo_t textype_dxt1a = {"dxt1a", TEXTYPE_DXT1A , 4, 0, 0.5f, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT , 0 , 0 }

static

Definition at line 136 of file gl_textures.c.

{"dxt1a",                    TEXTYPE_DXT1A         ,  4,  0,  0.5f, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT      , 0                 , 0                };

Referenced by R_GetTexTypeInfo().

textype_dxt3

textypeinfo_t textype_dxt3 = {"dxt3", TEXTYPE_DXT3 , 4, 0, 1.0f, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT , 0 , 0 }

static

Definition at line 137 of file gl_textures.c.

{"dxt3",                     TEXTYPE_DXT3          ,  4,  0,  1.0f, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT      , 0                 , 0                };

Referenced by R_GetTexTypeInfo().

textype_dxt5

textypeinfo_t textype_dxt5 = {"dxt5", TEXTYPE_DXT5 , 4, 0, 1.0f, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT , 0 , 0 }

static

Definition at line 138 of file gl_textures.c.

{"dxt5",                     TEXTYPE_DXT5          ,  4,  0,  1.0f, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT      , 0                 , 0                };

Referenced by R_GetTexTypeInfo().

textype_palette

textypeinfo_t textype_palette = {"palette", TEXTYPE_PALETTE , 1, 4, 4.0f, GL_RGB , GL_BGRA , GL_UNSIGNED_BYTE }

static

Definition at line 125 of file gl_textures.c.

{"palette",                  TEXTYPE_PALETTE       ,  1,  4,  4.0f, GL_RGB                                , GL_BGRA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_palette_alpha

textypeinfo_t textype_palette_alpha = {"palette_alpha", TEXTYPE_PALETTE , 1, 4, 4.0f, GL_RGBA , GL_BGRA , GL_UNSIGNED_BYTE }

static

Definition at line 126 of file gl_textures.c.

{"palette_alpha",            TEXTYPE_PALETTE       ,  1,  4,  4.0f, GL_RGBA                               , GL_BGRA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_rgba

textypeinfo_t textype_rgba = {"rgba", TEXTYPE_RGBA , 4, 4, 4.0f, GL_RGB , GL_RGBA , GL_UNSIGNED_BYTE }

static

Definition at line 127 of file gl_textures.c.

{"rgba",                     TEXTYPE_RGBA          ,  4,  4,  4.0f, GL_RGB                                , GL_RGBA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_rgba_alpha

textypeinfo_t textype_rgba_alpha = {"rgba_alpha", TEXTYPE_RGBA , 4, 4, 4.0f, GL_RGBA , GL_RGBA , GL_UNSIGNED_BYTE }

static

Definition at line 128 of file gl_textures.c.

{"rgba_alpha",               TEXTYPE_RGBA          ,  4,  4,  4.0f, GL_RGBA                               , GL_RGBA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_rgba_alpha_compress

textypeinfo_t textype_rgba_alpha_compress = {"rgba_alpha_compress", TEXTYPE_RGBA , 4, 4, 1.0f, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT , GL_RGBA , GL_UNSIGNED_BYTE }

static

Definition at line 130 of file gl_textures.c.

{"rgba_alpha_compress",      TEXTYPE_RGBA          ,  4,  4,  1.0f, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT      , GL_RGBA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_rgba_compress

textypeinfo_t textype_rgba_compress = {"rgba_compress", TEXTYPE_RGBA , 4, 4, 0.5f, GL_COMPRESSED_RGB_S3TC_DXT1_EXT , GL_RGBA , GL_UNSIGNED_BYTE }

static

Definition at line 129 of file gl_textures.c.

{"rgba_compress",            TEXTYPE_RGBA          ,  4,  4,  0.5f, GL_COMPRESSED_RGB_S3TC_DXT1_EXT       , GL_RGBA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_shadowmap16_comp

textypeinfo_t textype_shadowmap16_comp = {"shadowmap16_comp", TEXTYPE_SHADOWMAP16_COMP , 2, 2, 2.0f, GL_DEPTH_COMPONENT16 , GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT}

static

Definition at line 112 of file gl_textures.c.

{"shadowmap16_comp",         TEXTYPE_SHADOWMAP16_COMP     ,  2,  2,  2.0f, GL_DEPTH_COMPONENT16              , GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT};

Referenced by R_GetTexTypeInfo().

textype_shadowmap16_raw

textypeinfo_t textype_shadowmap16_raw = {"shadowmap16_raw", TEXTYPE_SHADOWMAP16_RAW , 2, 2, 2.0f, GL_DEPTH_COMPONENT16 , GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT}

static

Definition at line 113 of file gl_textures.c.

{"shadowmap16_raw",          TEXTYPE_SHADOWMAP16_RAW      ,  2,  2,  2.0f, GL_DEPTH_COMPONENT16              , GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT};

Referenced by R_GetTexTypeInfo().

textype_shadowmap24_comp

textypeinfo_t textype_shadowmap24_comp = {"shadowmap24_comp", TEXTYPE_SHADOWMAP24_COMP , 4, 4, 4.0f, GL_DEPTH_COMPONENT24 , GL_DEPTH_COMPONENT, GL_UNSIGNED_INT }

static

Definition at line 114 of file gl_textures.c.

{"shadowmap24_comp",         TEXTYPE_SHADOWMAP24_COMP     ,  4,  4,  4.0f, GL_DEPTH_COMPONENT24              , GL_DEPTH_COMPONENT, GL_UNSIGNED_INT  };

Referenced by R_GetTexTypeInfo().

textype_shadowmap24_raw

textypeinfo_t textype_shadowmap24_raw = {"shadowmap24_raw", TEXTYPE_SHADOWMAP24_RAW , 4, 4, 4.0f, GL_DEPTH_COMPONENT24 , GL_DEPTH_COMPONENT, GL_UNSIGNED_INT }

static

Definition at line 115 of file gl_textures.c.

{"shadowmap24_raw",          TEXTYPE_SHADOWMAP24_RAW      ,  4,  4,  4.0f, GL_DEPTH_COMPONENT24              , GL_DEPTH_COMPONENT, GL_UNSIGNED_INT  };

Referenced by R_GetTexTypeInfo().

textype_sRGB_bgra

textypeinfo_t textype_sRGB_bgra = {"sRGB_bgra", TEXTYPE_BGRA , 4, 4, 4.0f, GL_SRGB , GL_BGRA , GL_UNSIGNED_BYTE }

static

Definition at line 145 of file gl_textures.c.

{"sRGB_bgra",                TEXTYPE_BGRA          ,  4,  4,  4.0f, GL_SRGB                               , GL_BGRA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_sRGB_bgra_alpha

textypeinfo_t textype_sRGB_bgra_alpha = {"sRGB_bgra_alpha", TEXTYPE_BGRA , 4, 4, 4.0f, GL_SRGB_ALPHA , GL_BGRA , GL_UNSIGNED_BYTE }

static

Definition at line 146 of file gl_textures.c.

{"sRGB_bgra_alpha",          TEXTYPE_BGRA          ,  4,  4,  4.0f, GL_SRGB_ALPHA                         , GL_BGRA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_sRGB_bgra_alpha_compress

textypeinfo_t textype_sRGB_bgra_alpha_compress = {"sRGB_bgra_alpha_compress", TEXTYPE_BGRA , 4, 4, 1.0f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_BGRA , GL_UNSIGNED_BYTE }

static

Definition at line 148 of file gl_textures.c.

{"sRGB_bgra_alpha_compress", TEXTYPE_BGRA          ,  4,  4,  1.0f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_BGRA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_sRGB_bgra_compress

textypeinfo_t textype_sRGB_bgra_compress = {"sRGB_bgra_compress", TEXTYPE_BGRA , 4, 4, 0.5f, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT , GL_BGRA , GL_UNSIGNED_BYTE }

static

Definition at line 147 of file gl_textures.c.

{"sRGB_bgra_compress",       TEXTYPE_BGRA          ,  4,  4,  0.5f, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT      , GL_BGRA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_sRGB_dxt1

textypeinfo_t textype_sRGB_dxt1 = {"sRGB_dxt1", TEXTYPE_DXT1 , 4, 0, 0.5f, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT , 0 , 0 }

static

Definition at line 149 of file gl_textures.c.

{"sRGB_dxt1",                TEXTYPE_DXT1          ,  4,  0,  0.5f, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT      , 0                 , 0                };

Referenced by R_GetTexTypeInfo().

textype_sRGB_dxt1a

textypeinfo_t textype_sRGB_dxt1a = {"sRGB_dxt1a", TEXTYPE_DXT1A , 4, 0, 0.5f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0 , 0 }

static

Definition at line 150 of file gl_textures.c.

{"sRGB_dxt1a",               TEXTYPE_DXT1A         ,  4,  0,  0.5f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0                 , 0                };

Referenced by R_GetTexTypeInfo().

textype_sRGB_dxt3

textypeinfo_t textype_sRGB_dxt3 = {"sRGB_dxt3", TEXTYPE_DXT3 , 4, 0, 1.0f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0 , 0 }

static

Definition at line 151 of file gl_textures.c.

{"sRGB_dxt3",                TEXTYPE_DXT3          ,  4,  0,  1.0f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0                 , 0                };

Referenced by R_GetTexTypeInfo().

textype_sRGB_dxt5

textypeinfo_t textype_sRGB_dxt5 = {"sRGB_dxt5", TEXTYPE_DXT5 , 4, 0, 1.0f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0 , 0 }

static

Definition at line 152 of file gl_textures.c.

{"sRGB_dxt5",                TEXTYPE_DXT5          ,  4,  0,  1.0f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0                 , 0                };

Referenced by R_GetTexTypeInfo().

textype_sRGB_palette

textypeinfo_t textype_sRGB_palette = {"sRGB_palette", TEXTYPE_PALETTE , 1, 4, 4.0f, GL_SRGB , GL_BGRA , GL_UNSIGNED_BYTE }

static

Definition at line 139 of file gl_textures.c.

{"sRGB_palette",             TEXTYPE_PALETTE       ,  1,  4,  4.0f, GL_SRGB                               , GL_BGRA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_sRGB_palette_alpha

textypeinfo_t textype_sRGB_palette_alpha = {"sRGB_palette_alpha", TEXTYPE_PALETTE , 1, 4, 4.0f, GL_SRGB_ALPHA , GL_BGRA , GL_UNSIGNED_BYTE }

static

Definition at line 140 of file gl_textures.c.

{"sRGB_palette_alpha",       TEXTYPE_PALETTE       ,  1,  4,  4.0f, GL_SRGB_ALPHA                         , GL_BGRA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_sRGB_rgba

textypeinfo_t textype_sRGB_rgba = {"sRGB_rgba", TEXTYPE_RGBA , 4, 4, 4.0f, GL_SRGB , GL_RGBA , GL_UNSIGNED_BYTE }

static

Definition at line 141 of file gl_textures.c.

{"sRGB_rgba",                TEXTYPE_RGBA          ,  4,  4,  4.0f, GL_SRGB                               , GL_RGBA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_sRGB_rgba_alpha

textypeinfo_t textype_sRGB_rgba_alpha = {"sRGB_rgba_alpha", TEXTYPE_RGBA , 4, 4, 4.0f, GL_SRGB_ALPHA , GL_RGBA , GL_UNSIGNED_BYTE }

static

Definition at line 142 of file gl_textures.c.

{"sRGB_rgba_alpha",          TEXTYPE_RGBA          ,  4,  4,  4.0f, GL_SRGB_ALPHA                         , GL_RGBA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_sRGB_rgba_alpha_compress

textypeinfo_t textype_sRGB_rgba_alpha_compress = {"sRGB_rgba_alpha_compress", TEXTYPE_RGBA , 4, 4, 1.0f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_RGBA , GL_UNSIGNED_BYTE }

static

Definition at line 144 of file gl_textures.c.

{"sRGB_rgba_alpha_compress", TEXTYPE_RGBA          ,  4,  4,  1.0f, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_RGBA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().

textype_sRGB_rgba_compress

textypeinfo_t textype_sRGB_rgba_compress = {"sRGB_rgba_compress", TEXTYPE_RGBA , 4, 4, 0.5f, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT , GL_RGBA , GL_UNSIGNED_BYTE }

static

Definition at line 143 of file gl_textures.c.

{"sRGB_rgba_compress",       TEXTYPE_RGBA          ,  4,  4,  0.5f, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT      , GL_RGBA           , GL_UNSIGNED_BYTE };

Referenced by R_GetTexTypeInfo().