#include "qtypes.h"
#include "qdefs.h"

Include dependency graph for r_textures.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	rtexture_t

struct	rtexturepool_t

struct	skinframe_t

Macros
#define	R_GetTexture(rt)

#define	TEXF_ALLOWUPDATES 0x00002000

#define	TEXF_ALPHA 0x00000001

#define	TEXF_CLAMP 0x00000020

#define	TEXF_COMPARE 0x00000800

#define	TEXF_COMPRESS 0x00000200

#define	TEXF_FORCE_RELOAD 0x80000000

#define	TEXF_FORCELINEAR 0x00000080

#define	TEXF_FORCENEAREST 0x00000040

#define	TEXF_IMPORTANTBITS (TEXF_ALPHA \| TEXF_MIPMAP \| TEXF_RGBMULTIPLYBYALPHA \| TEXF_CLAMP \| TEXF_FORCENEAREST \| TEXF_FORCELINEAR \| TEXF_PICMIP \| TEXF_COMPARE \| TEXF_LOWPRECISION \| TEXF_RENDERTARGET)

#define	TEXF_ISSPRITE 0x00008000

#define	TEXF_ISWORLD 0x00004000

#define	TEXF_LOWPRECISION 0x00001000

#define	TEXF_MIPMAP 0x00000002

#define	TEXF_PERSISTENT 0x00000400

#define	TEXF_PICMIP 0x00000100

#define	TEXF_RENDERTARGET 0x0010000

#define	TEXF_RGBMULTIPLYBYALPHA 0x00000004

Typedefs
typedef void(*	updatecallback_t) (rtexture_t rt, void data)

Functions
rtexturepool_t *	R_AllocTexturePool (void)

void	R_ClearTexture (rtexture_t *rt)

void	R_FreeTexture (rtexture_t *rt)

void	R_FreeTexturePool (rtexturepool_t **rtexturepool)

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)

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 *prt)

int	R_RealGetTexture (rtexture_t *rt)

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

int	R_TextureFlags (rtexture_t *rt)

int	R_TextureHeight (rtexture_t *rt)

void	R_Textures_Frame (void)

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

int	R_TextureWidth (rtexture_t *rt)

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

Variables
struct cvar_s	gl_texturecompression

struct cvar_s	gl_texturecompression_2d

struct cvar_s	gl_texturecompression_color

struct cvar_s	gl_texturecompression_gloss

struct cvar_s	gl_texturecompression_glow

struct cvar_s	gl_texturecompression_lightcubemaps

struct cvar_s	gl_texturecompression_normal

struct cvar_s	gl_texturecompression_q3bspdeluxemaps

struct cvar_s	gl_texturecompression_q3bsplightmaps

struct cvar_s	gl_texturecompression_reflectmask

struct cvar_s	gl_texturecompression_sky

struct cvar_s	r_texture_dds_load

struct cvar_s	r_texture_dds_save

Macro Definition Documentation

◆ R_GetTexture

#define R_GetTexture ( rt )

Value:

((rt) ? ((rt)->dirty ? R_RealGetTexture(rt) : (rt)->texnum) : r_texture_white->texnum)

r_texture_white

rtexture_t * r_texture_white

Definition gl_rmain.c:273

R_RealGetTexture

int R_RealGetTexture(rtexture_t *rt)

Definition gl_textures.c:2358

Definition at line 214 of file r_textures.h.

Referenced by R_Mesh_TexBind().

◆ TEXF_ALLOWUPDATES

#define TEXF_ALLOWUPDATES 0x00002000

Definition at line 31 of file r_textures.h.

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

◆ TEXF_ALPHA

#define TEXF_ALPHA 0x00000001

Definition at line 9 of file r_textures.h.

Referenced by CL_Beams_SetupExternalTexture(), Curl_EndDownload(), Draw_CachePic_Flags(), DrawQ_String_Scale(), Mod_BuildAliasSkinsFromSkinFiles(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDS2_Load(), Mod_LoadQ3Shaders(), Mod_Q1BSP_LoadSplitSky(), Mod_Q1BSP_LoadTextures(), Mod_Q2BSP_LoadTexinfo(), Mod_Sprite_SharedSetup(), R_BuildFogHeightTexture(), r_explosion_start(), R_GetTexTypeInfo(), R_InitParticleTexture(), R_LoadTextureDDSFile(), R_ReplaceWorldTexture_f(), R_SetupShader_Surface(), R_SetupTexture(), R_Shadow_BounceGrid_ConvertPixelsAndUpload(), R_Shadow_MakeShadowMap(), R_Shadow_MakeTextures(), R_Shadow_MakeVSDCT(), R_Shadow_PrepareLights(), R_SkinFrame_GenerateTexturesFromQPixels(), R_SkinFrame_LoadExternal_SkinFrame(), R_SkinFrame_LoadInternal8bit(), R_SkinFrame_LoadInternalBGRA(), R_SkinFrame_LoadInternalUsingTexture(), R_TextureStats_Print(), update_pic_for_fontmap(), and VM_CL_R_PolygonEnd().

◆ TEXF_CLAMP

#define TEXF_CLAMP 0x00000020

◆ TEXF_COMPARE

#define TEXF_COMPARE 0x00000800

Definition at line 27 of file r_textures.h.

◆ TEXF_COMPRESS

#define TEXF_COMPRESS 0x00000200

Definition at line 23 of file r_textures.h.

Referenced by Draw_CachePic_Flags(), Mod_BuildAliasSkinsFromSkinFiles(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDS2_Load(), Mod_LoadQ3Shaders(), Mod_LoadTextureFromQ3Shader(), Mod_Q1BSP_LoadTextures(), Mod_Q2BSP_LoadTexinfo(), Mod_Q3BSP_LoadLightmaps(), Mod_Q3BSP_LoadTextures(), Mod_Sprite_SharedSetup(), R_GetTexTypeInfo(), R_LoadCubemap(), R_LoadSkyBox(), R_SkinFrame_LoadExternal_SkinFrame(), and update_pic_for_fontmap().

◆ TEXF_FORCE_RELOAD

#define TEXF_FORCE_RELOAD 0x80000000

Definition at line 41 of file r_textures.h.

Referenced by Curl_EndDownload(), Draw_CachePic_Flags(), Draw_GetPicTexture(), Draw_IsPicLoaded(), Draw_NewPic(), and R_SkinFrame_Find().

◆ TEXF_FORCELINEAR

◆ TEXF_FORCENEAREST

#define TEXF_FORCENEAREST 0x00000040

Definition at line 17 of file r_textures.h.

Referenced by Draw_CachePic_Flags(), Draw_NewPic(), GL_SetupTextureParameters(), GL_TextureMode_f(), R_LoadCubemap(), R_LoadTextureRenderBuffer(), R_LoadTextureShadowMap2D(), R_Shadow_MakeShadowMap(), R_Shadow_MakeVSDCT(), R_Shadow_PrepareLights(), R_SkinFrame_LoadMissing(), R_SkinFrame_LoadNoTexture(), and SCR_SetLoadingScreenTexture().

◆ TEXF_IMPORTANTBITS

Definition at line 39 of file r_textures.h.

Referenced by R_SkinFrame_Find().

◆ TEXF_ISSPRITE

#define TEXF_ISSPRITE 0x00008000

Definition at line 35 of file r_textures.h.

Referenced by Mod_IDS2_Load(), Mod_LoadTextureFromQ3Shader(), Mod_Sprite_SharedSetup(), and R_PicmipForFlags().

◆ TEXF_ISWORLD

#define TEXF_ISWORLD 0x00004000

Definition at line 33 of file r_textures.h.

Referenced by Mod_LoadTextureFromQ3Shader(), Mod_Q1BSP_LoadTextures(), Mod_Q2BSP_LoadTexinfo(), Mod_Q3BSP_LoadTextures(), and R_PicmipForFlags().

◆ TEXF_LOWPRECISION

#define TEXF_LOWPRECISION 0x00001000

Definition at line 29 of file r_textures.h.

◆ TEXF_MIPMAP

◆ TEXF_PERSISTENT

#define TEXF_PERSISTENT 0x00000400

Definition at line 25 of file r_textures.h.

Referenced by R_BuildBlankTextures(), R_BuildFogTexture(), R_BuildNormalizationCube(), R_BuildNoTexture(), R_BuildWhiteCube(), R_PurgeTexture(), and R_UpdateVariables().

◆ TEXF_PICMIP

#define TEXF_PICMIP 0x00000100

Definition at line 21 of file r_textures.h.

Referenced by GL_Texture_CalcImageSize(), Mod_BuildAliasSkinsFromSkinFiles(), Mod_IDP0_Load(), Mod_IDP2_Load(), Mod_IDS2_Load(), Mod_LoadQ3Shaders(), Mod_LoadTextureFromQ3Shader(), Mod_Q1BSP_LoadTextures(), Mod_Q2BSP_LoadTexinfo(), Mod_Q3BSP_LoadTextures(), Mod_Sprite_SharedSetup(), R_LoadQWSkin(), R_PicmipForFlags(), R_ReplaceWorldTexture_f(), and R_UploadPartialTexture().

◆ TEXF_RENDERTARGET

#define TEXF_RENDERTARGET 0x0010000

Definition at line 37 of file r_textures.h.

Referenced by R_Bloom_StartFrame(), R_LoadTextureRenderBuffer(), R_LoadTextureShadowMap2D(), R_RenderTarget_Get(), R_Shadow_MakeShadowMap(), R_Shadow_PrepareLights(), r_textures_devicelost(), r_textures_devicerestored(), and SCR_SetLoadingScreenTexture().

◆ TEXF_RGBMULTIPLYBYALPHA

#define TEXF_RGBMULTIPLYBYALPHA 0x00000004

Definition at line 13 of file r_textures.h.

Referenced by R_InitParticleTexture(), R_LoadTextureDDSFile(), R_SaveTextureDDSFile(), and R_UploadFullTexture().

Typedef Documentation

◆ updatecallback_t

typedef void(* updatecallback_t) (rtexture_t *rt, void *data)

Definition at line 168 of file r_textures.h.

Enumeration Type Documentation

◆ textype_t

enum textype_t

Enumerator
TEXTYPE_UNUSED
TEXTYPE_PALETTE
TEXTYPE_RGBA
TEXTYPE_BGRA
TEXTYPE_ALPHA
TEXTYPE_DXT1
TEXTYPE_DXT1A
TEXTYPE_DXT3
TEXTYPE_DXT5
TEXTYPE_ETC1
TEXTYPE_SRGB_PALETTE
TEXTYPE_SRGB_RGBA
TEXTYPE_SRGB_BGRA
TEXTYPE_SRGB_DXT1
TEXTYPE_SRGB_DXT1A
TEXTYPE_SRGB_DXT3
TEXTYPE_SRGB_DXT5
TEXTYPE_COLORBUFFER
TEXTYPE_COLORBUFFER16F
TEXTYPE_COLORBUFFER32F
TEXTYPE_DEPTHBUFFER16
TEXTYPE_DEPTHBUFFER24
TEXTYPE_DEPTHBUFFER24STENCIL8
TEXTYPE_SHADOWMAP16_COMP
TEXTYPE_SHADOWMAP16_RAW
TEXTYPE_SHADOWMAP24_COMP
TEXTYPE_SHADOWMAP24_RAW

Definition at line 43 of file r_textures.h.

{
    // placeholder for unused textures in r_rendertarget_t
    TEXTYPE_UNUSED,
 
    // 8bit paletted
    TEXTYPE_PALETTE,
    // 32bit RGBA
    TEXTYPE_RGBA,
    // 32bit BGRA (preferred format due to faster uploads on most hardware)
    TEXTYPE_BGRA,
    // 8bit ALPHA (used for freetype fonts)
    TEXTYPE_ALPHA,
    // 4x4 block compressed 15bit color (4 bits per pixel)
    TEXTYPE_DXT1,
    // 4x4 block compressed 15bit color plus 1bit alpha (4 bits per pixel)
    TEXTYPE_DXT1A,
    // 4x4 block compressed 15bit color plus 8bit alpha (8 bits per pixel)
    TEXTYPE_DXT3,
    // 4x4 block compressed 15bit color plus 8bit alpha (8 bits per pixel)
    TEXTYPE_DXT5,
 
    // default compressed type for GLES2
    TEXTYPE_ETC1,
 
    // 8bit paletted in sRGB colorspace
    TEXTYPE_SRGB_PALETTE,
    // 32bit RGBA in sRGB colorspace
    TEXTYPE_SRGB_RGBA,
    // 32bit BGRA (preferred format due to faster uploads on most hardware) in sRGB colorspace
    TEXTYPE_SRGB_BGRA,
    // 4x4 block compressed 15bit color (4 bits per pixel) in sRGB colorspace
    TEXTYPE_SRGB_DXT1,
    // 4x4 block compressed 15bit color plus 1bit alpha (4 bits per pixel) in sRGB colorspace
    TEXTYPE_SRGB_DXT1A,
    // 4x4 block compressed 15bit color plus 8bit alpha (8 bits per pixel) in sRGB colorspace
    TEXTYPE_SRGB_DXT3,
    // 4x4 block compressed 15bit color plus 8bit alpha (8 bits per pixel) in sRGB colorspace
    TEXTYPE_SRGB_DXT5,
 
    // this represents the same format as the framebuffer, for fast copies
    TEXTYPE_COLORBUFFER,
    // this represents an RGBA half_float texture (4 16bit floats)
    TEXTYPE_COLORBUFFER16F,
    // this represents an RGBA float texture (4 32bit floats)
    TEXTYPE_COLORBUFFER32F,
    // depth-stencil buffer (or texture)
    TEXTYPE_DEPTHBUFFER16,
    // depth-stencil buffer (or texture)
    TEXTYPE_DEPTHBUFFER24,
    // 32bit D24S8 buffer (24bit depth, 8bit stencil), not supported on OpenGL ES
    TEXTYPE_DEPTHBUFFER24STENCIL8,
    // shadowmap-friendly format with depth comparison (not supported on some hardware)
    TEXTYPE_SHADOWMAP16_COMP,
    // shadowmap-friendly format with raw reading (not supported on some hardware)
    TEXTYPE_SHADOWMAP16_RAW,
    // shadowmap-friendly format with depth comparison (not supported on some hardware)
    TEXTYPE_SHADOWMAP24_COMP,
    // shadowmap-friendly format with raw reading (not supported on some hardware)
    TEXTYPE_SHADOWMAP24_RAW,
}

Function Documentation

◆ 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_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_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_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 * prt )

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_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_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_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_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().

Variable Documentation

◆ gl_texturecompression

struct cvar_s gl_texturecompression

extern

Definition at line 37 of file gl_textures.c.

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

CF_CLIENT

#define CF_CLIENT

cvar/command that only the client can change/execute

Definition cmd.h:48

CF_ARCHIVE

#define CF_ARCHIVE

cvar should have its set value saved to config.cfg and persist across sessions

Definition cmd.h:53

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

struct cvar_s gl_texturecompression_2d

extern

Definition at line 42 of file gl_textures.c.

42{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

struct cvar_s gl_texturecompression_color

extern

Definition at line 38 of file gl_textures.c.

38{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

struct cvar_s gl_texturecompression_gloss

extern

Definition at line 40 of file gl_textures.c.

40{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

struct cvar_s gl_texturecompression_glow

extern

Definition at line 41 of file gl_textures.c.

41{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

struct cvar_s gl_texturecompression_lightcubemaps

extern

Definition at line 46 of file gl_textures.c.

46{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

struct cvar_s gl_texturecompression_normal

extern

Definition at line 39 of file gl_textures.c.

39{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

struct cvar_s gl_texturecompression_q3bspdeluxemaps

extern

Definition at line 44 of file gl_textures.c.

44{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

struct cvar_s gl_texturecompression_q3bsplightmaps

extern

Definition at line 43 of file gl_textures.c.

43{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

struct cvar_s gl_texturecompression_reflectmask

extern

Definition at line 47 of file gl_textures.c.

47{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

struct cvar_s gl_texturecompression_sky

extern

Definition at line 45 of file gl_textures.c.

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

Referenced by R_LoadSkyBox(), and R_Textures_Init().

◆ r_texture_dds_load

struct cvar_s r_texture_dds_load

extern

Definition at line 156 of file gl_rmain.c.

156{CF_CLIENT | CF_ARCHIVE, "r_texture_dds_load", "0", "load compressed dds/filename.dds texture instead of filename.tga, if the file exists (requires driver support)"};

Referenced by GL_Main_Init(), and gl_main_start().

◆ r_texture_dds_save

struct cvar_s r_texture_dds_save

extern

Definition at line 157 of file gl_rmain.c.

157{CF_CLIENT | CF_ARCHIVE, "r_texture_dds_save", "0", "save compressed dds/filename.dds texture when filename.tga is loaded, so that it can be loaded instead next time"};

Referenced by GL_Main_Init(), gl_main_start(), and R_SkinFrame_LoadExternal_SkinFrame().

Enumerations
enum	textype_t { TEXTYPE_UNUSED , TEXTYPE_PALETTE , TEXTYPE_RGBA , TEXTYPE_BGRA , TEXTYPE_ALPHA , TEXTYPE_DXT1 , TEXTYPE_DXT1A , TEXTYPE_DXT3 , TEXTYPE_DXT5 , TEXTYPE_ETC1 , TEXTYPE_SRGB_PALETTE , TEXTYPE_SRGB_RGBA , TEXTYPE_SRGB_BGRA , TEXTYPE_SRGB_DXT1 , TEXTYPE_SRGB_DXT1A , TEXTYPE_SRGB_DXT3 , TEXTYPE_SRGB_DXT5 , TEXTYPE_COLORBUFFER , TEXTYPE_COLORBUFFER16F , TEXTYPE_COLORBUFFER32F , TEXTYPE_DEPTHBUFFER16 , TEXTYPE_DEPTHBUFFER24 , TEXTYPE_DEPTHBUFFER24STENCIL8 , TEXTYPE_SHADOWMAP16_COMP , TEXTYPE_SHADOWMAP16_RAW , TEXTYPE_SHADOWMAP24_COMP , TEXTYPE_SHADOWMAP24_RAW }

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ R_GetTexture

◆ TEXF_ALLOWUPDATES

◆ TEXF_ALPHA

◆ TEXF_CLAMP

◆ TEXF_COMPARE

◆ TEXF_COMPRESS

◆ TEXF_FORCE_RELOAD

◆ TEXF_FORCELINEAR

◆ TEXF_FORCENEAREST

◆ TEXF_IMPORTANTBITS

◆ TEXF_ISSPRITE

◆ TEXF_ISWORLD

◆ TEXF_LOWPRECISION

◆ TEXF_MIPMAP

◆ TEXF_PERSISTENT

◆ TEXF_PICMIP

◆ TEXF_RENDERTARGET

◆ TEXF_RGBMULTIPLYBYALPHA

Typedef Documentation

◆ updatecallback_t

Enumeration Type Documentation

◆ textype_t

Function Documentation

◆ R_AllocTexturePool()

◆ R_ClearTexture()

◆ R_FreeTexture()

◆ R_FreeTexturePool()

◆ R_LoadTexture2D()

◆ R_LoadTexture3D()

◆ R_LoadTextureCubeMap()

◆ R_LoadTextureDDSFile()

◆ R_LoadTextureRenderBuffer()

◆ R_LoadTextureShadowMap2D()

◆ R_MakeTextureDynamic()

◆ R_MarkDirtyTexture()

◆ R_PicmipForFlags()

◆ R_PurgeTexture()

◆ R_RealGetTexture()

◆ R_SaveTextureDDSFile()

◆ R_TextureFlags()

◆ R_TextureHeight()

◆ R_Textures_Frame()

◆ R_TextureStats_Print()

◆ R_TextureWidth()

◆ R_UpdateTexture()

Variable Documentation

◆ 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

◆ r_texture_dds_load

◆ r_texture_dds_save