images.c File Reference

#include "shared/shared.h"
#include "common/common.h"
#include "common/cvar.h"
#include "common/files.h"
#include "refresh/images.h"
#include "format/pcx.h"
#include "format/wal.h"
#include "stb_image.h"
#include "stb_image_write.h"

Go to the source code of this file.

Classes
struct	floodfill_t

Macros
#define	R_COLORMAP_PCX   "pics/colormap.pcx"
#define	IMG_LOAD(x)
#define	IMG_SAVE(x)
#define	FLOODFILL_FIFO_SIZE   0x1000
#define	FLOODFILL_FIFO_MASK   (FLOODFILL_FIFO_SIZE - 1)
#define	FLOODFILL_STEP(off, dx, dy)
#define	RIMAGES_HASH   256

Functions
void	stbi_write (void *context, void *data, int size)
static void	IMG_FloodFill (byte *skin, int skinwidth, int skinheight)
static qerror_t	IMG_DecodePCX (byte *rawdata, size_t rawlen, byte *pixels, byte *palette, int *width, int *height)
static int	IMG_Unpack8 (uint32_t *out, const uint8_t *in, int width, int height)
	IMG_LOAD (PCX)
	IMG_LOAD (WAL)
	IMG_LOAD (STB)
	IMG_SAVE (TGA)
	IMG_SAVE (JPG)
	IMG_SAVE (PNG)
static qhandle_t	create_screenshot (char *buffer, size_t size, const char *name, const char *ext)
static void	make_screenshot (const char *name, const char *ext, qerror_t(*save)(qhandle_t, const char *, byte *, int, int, int, int), int param)
static void	IMG_ScreenShot_f (void)
static void	IMG_ScreenShotTGA_f (void)
static void	IMG_ScreenShotJPG_f (void)
static void	IMG_ScreenShotPNG_f (void)
void	IMG_ResampleTexture (const byte *in, int inwidth, int inheight, byte *out, int outwidth, int outheight)
void	IMG_MipMap (byte *out, byte *in, int width, int height)
static void	IMG_List_f (void)
static image_t *	alloc_image (void)
static image_t *	lookup_image (const char *name, imagetype_t type, unsigned hash, size_t baselen)
static int	_try_image_format (imageformat_t fmt, image_t *image, byte **pic)
static int	try_image_format (imageformat_t fmt, image_t *image, byte **pic)
static int	try_other_formats (imageformat_t orig, image_t *image, byte **pic)
static void	get_image_dimensions (imageformat_t fmt, image_t *image)
static void	r_texture_formats_changed (cvar_t *self)
qerror_t	load_img (const char *name, image_t *image)
static qerror_t	find_or_load_image (const char *name, size_t len, imagetype_t type, imageflags_t flags, image_t **image_p)
image_t *	IMG_Find (const char *name, imagetype_t type, imageflags_t flags)
image_t *	IMG_ForHandle (qhandle_t h)
qhandle_t	R_RegisterImage (const char *name, imagetype_t type, imageflags_t flags, qerror_t *err_p)
qhandle_t	R_RegisterRawImage (const char *name, int width, int height, byte *pic, imagetype_t type, imageflags_t flags)
void	R_UnregisterImage (qhandle_t handle)
qboolean	R_GetPicSize (int *w, int *h, qhandle_t pic)
void	IMG_FreeUnused (void)
void	IMG_FreeAll (void)
void	IMG_GetPalette (void)
void	IMG_Init (void)
void	IMG_Shutdown (void)

Variables
cvar_t *	vid_rtx
static cvar_t *	r_screenshot_format
static cvar_t *	r_screenshot_quality
static cvar_t *	r_screenshot_compression
static list_t	r_imageHash [RIMAGES_HASH]
image_t	r_images [MAX_RIMAGES]
int	r_numImages
uint32_t	d_8to24table [256]
struct {
char   ext [4]
qerror_t(*   load )(byte *, size_t, image_t       *, byte **)
}	img_loaders [IM_MAX]
static imageformat_t	img_search [IM_MAX]
static int	img_total
static cvar_t *	r_override_textures
static cvar_t *	r_texture_formats
static const cmdreg_t	img_cmd []

Macro Definition Documentation

FLOODFILL_FIFO_MASK

#define FLOODFILL_FIFO_MASK   (FLOODFILL_FIFO_SIZE - 1)

Definition at line 66 of file images.c.

FLOODFILL_FIFO_SIZE

#define FLOODFILL_FIFO_SIZE   0x1000

Definition at line 65 of file images.c.

FLOODFILL_STEP

#define FLOODFILL_STEP	(		off,
			dx,
			dy
	)

Value:

    do { \
        if (pos[off] == fillcolor) { \
            pos[off] = 255; \
            fifo[inpt].x = x + (dx); \
            fifo[inpt].y = y + (dy); \
            inpt = (inpt + 1) & FLOODFILL_FIFO_MASK; \
        } else if (pos[off] != 255) { \
            fdc = pos[off]; \
        } \
    } while(0)

Definition at line 68 of file images.c.

IMG_LOAD

#define IMG_LOAD

(

x

)

Value:

    static qerror_t IMG_Load##x(byte *rawdata, size_t rawlen, \
        image_t *image, byte **pic)

Definition at line 37 of file images.c.

IMG_SAVE

#define IMG_SAVE

(

x

)

Value:

    static qerror_t IMG_Save##x(qhandle_t f, const char *filename, \
        byte *pic, int width, int height, int row_stride, int param)

Definition at line 41 of file images.c.

R_COLORMAP_PCX

#define R_COLORMAP_PCX   "pics/colormap.pcx"

Definition at line 35 of file images.c.

RIMAGES_HASH

#define RIMAGES_HASH   256

Definition at line 647 of file images.c.

Function Documentation

_try_image_format()

static int _try_image_format ( imageformat_t  fmt, image_t *  image, byte **  pic  )

static

Definition at line 787 of file images.c.

{
    byte        *data;
    ssize_t     len;
    qerror_t    ret;
 
    // load the file
    len = FS_LoadFile(image->name, (void **)&data);
    if (!data) {
        return len;
    }
 
    // decompress the image
    ret = img_loaders[fmt].load(data, len, image, pic);
 
    FS_FreeFile(data);
 
    image->filepath[0] = 0;
    if (ret >= 0) {
        strcpy(image->filepath, image->name);
        // record last modified time (skips reload when invoking IMG_ReloadAll)
        image->last_modified = 0;
        FS_LastModified(image->filepath, &image->last_modified);
    }
    return ret < 0 ? ret : fmt;
}

Referenced by find_or_load_image(), load_img(), and try_image_format().

alloc_image()

static image_t* alloc_image ( void  )

static

Definition at line 744 of file images.c.

{
    int i;
    image_t *image;
 
    // find a free image_t slot
    for (i = 1, image = r_images + 1; i < r_numImages; i++, image++) {
        if (!image->registration_sequence)
            break;
    }
 
    if (i == r_numImages) {
        if (r_numImages == MAX_RIMAGES)
            return NULL;
        r_numImages++;
    }
 
    return image;
}

Referenced by find_or_load_image(), and R_RegisterRawImage().

create_screenshot()

static qhandle_t create_screenshot ( char *  buffer, size_t  size, const char *  name, const char *  ext  )

static

Definition at line 415 of file images.c.

{
    qhandle_t f;
    qerror_t ret;
    int i;
 
    if (name && *name) {
        // save to user supplied name
        return FS_EasyOpenFile(buffer, size, FS_MODE_WRITE,
                               "screenshots/", name, ext);
    }
 
    // find a file name to save it to
    for (i = 0; i < 1000; i++) {
        Q_snprintf(buffer, size, "screenshots/quake%03d%s", i, ext);
        ret = FS_FOpenFile(buffer, &f, FS_MODE_WRITE | FS_FLAG_EXCL);
        if (f) {
            return f;
        }
        if (ret != Q_ERR_EXIST) {
            Com_EPrintf("Couldn't exclusively open %s for writing: %s\n",
                        buffer, Q_ErrorString(ret));
            return 0;
        }
    }
 
    Com_EPrintf("All screenshot slots are full.\n");
    return 0;
}

Referenced by make_screenshot().

find_or_load_image()

static qerror_t find_or_load_image ( const char *  name, size_t  len, imagetype_t  type, imageflags_t  flags, image_t **  image_p  )

static

Definition at line 991 of file images.c.

{
    image_t         *image;
    byte            *pic;
    unsigned        hash;
    imageformat_t   fmt;
    qerror_t        ret;
 
    *image_p = NULL;
 
    // must have an extension and at least 1 char of base name
    if (len <= 4) {
        return Q_ERR_NAMETOOSHORT;
    }
    if (name[len - 4] != '.') {
        return Q_ERR_INVALID_PATH;
    }
 
    hash = FS_HashPathLen(name, len - 4, RIMAGES_HASH);
 
    // look for it
    if ((image = lookup_image(name, type, hash, len - 4)) != NULL) {
        image->flags |= flags & IF_PERMANENT;
        image->registration_sequence = registration_sequence;
        *image_p = image;
        return Q_ERR_SUCCESS;
    }
 
    // allocate image slot
    image = alloc_image();
    if (!image) {
        return Q_ERR_OUT_OF_SLOTS;
    }
 
    int override_textures = !!r_override_textures->integer;
    if (!vid_rtx->integer && (type != IT_PIC))
        override_textures = 0;
 
    for (int use_override = override_textures; use_override >= 0; use_override--)
    {
        // fill in some basic info
        if (use_override)
        {
            const char* last_slash = strrchr(name, '/');
            if (!last_slash) 
                last_slash = name; 
            else 
                last_slash += 1;
 
            strcpy(image->name, "overrides/");
            strcat(image->name, last_slash);
            image->baselen = strlen(image->name) - 4;
        }
        else
        {
            memcpy(image->name, name, len + 1);
            image->baselen = len - 4;
        }
        image->type = type;
        image->flags = flags;
        image->registration_sequence = registration_sequence;
 
        // find out original extension
        for (fmt = 0; fmt < IM_MAX; fmt++) {
            if (!Q_stricmp(image->name + image->baselen + 1, img_loaders[fmt].ext)) {
                break;
            }
        }
 
        // load the pic from disk
        pic = NULL;
 
        if (fmt == IM_MAX) {
            // unknown extension, but give it a chance to load anyway
            ret = try_other_formats(IM_MAX, image, &pic);
            if (ret == Q_ERR_NOENT) {
                // not found, change error to invalid path
                ret = Q_ERR_INVALID_PATH;
            }
        }
        else if (override_textures) {
            // forcibly replace the extension
            ret = try_other_formats(IM_MAX, image, &pic);
        }
        else {
            // first try with original extension
            ret = _try_image_format(fmt, image, &pic);
            if (ret == Q_ERR_NOENT) {
                // retry with remaining extensions
                ret = try_other_formats(fmt, image, &pic);
            }
        }
 
        // record last modified time (skips reload when invoking IMG_ReloadAll)
        image->last_modified = 0;
        FS_LastModified(image->name, &image->last_modified);
 
        if (use_override)
        {
            memcpy(image->name, name, len + 1);
            image->baselen = len - 4;
        }
 
        // if we are replacing 8-bit texture with a higher resolution 32-bit
        // texture, we need to recover original image dimensions
        if (fmt <= IM_WAL && ret > IM_WAL) {
            get_image_dimensions(fmt, image);
        }
 
        if(ret >= 0)
            break;
    }
 
    if (ret < 0) {
        memset(image, 0, sizeof(*image));
        return ret;
    }
 
    List_Append(&r_imageHash[hash], &image->entry);
 
    image->is_srgb = !!(flags & IF_SRGB);
 
    // upload the image
    IMG_Load(image, pic);
 
    *image_p = image;
    return Q_ERR_SUCCESS;
}

Referenced by IMG_Find(), and R_RegisterImage().

get_image_dimensions()

static void get_image_dimensions ( imageformat_t  fmt, image_t *  image  )

static

Definition at line 851 of file images.c.

{
    char        buffer[MAX_QPATH];
    ssize_t     len;
    miptex_t    mt;
    dpcx_t      pcx;
    qhandle_t   f;
    unsigned    w, h;
 
    memcpy(buffer, image->name, image->baselen + 1);
 
    w = h = 0;
    if (fmt == IM_WAL) {
        memcpy(buffer + image->baselen + 1, "wal", 4);
        FS_FOpenFile(buffer, &f, FS_MODE_READ);
        if (f) {
            len = FS_Read(&mt, sizeof(mt), f);
            if (len == sizeof(mt)) {
                w = LittleLong(mt.width);
                h = LittleLong(mt.height);
            }
            FS_FCloseFile(f);
        }
    } else {
        memcpy(buffer + image->baselen + 1, "pcx", 4);
        FS_FOpenFile(buffer, &f, FS_MODE_READ);
        if (f) {
            len = FS_Read(&pcx, sizeof(pcx), f);
            if (len == sizeof(pcx)) {
                w = LittleShort(pcx.xmax) + 1;
                h = LittleShort(pcx.ymax) + 1;
            }
            FS_FCloseFile(f);
        }
    }
 
    if (w < 1 || h < 1 || w > 512 || h > 512) {
        return;
    }
 
    image->width = w;
    image->height = h;
}

Referenced by find_or_load_image(), and load_img().

IMG_DecodePCX()

static qerror_t IMG_DecodePCX ( byte *  rawdata, size_t  rawlen, byte *  pixels, byte *  palette, int *  width, int *  height  )

static

Definition at line 127 of file images.c.

{
    byte    *raw, *end;
    dpcx_t  *pcx;
    int     x, y, w, h, scan;
    int     dataByte, runLength;
 
    //
    // parse the PCX file
    //
    if (rawlen < sizeof(dpcx_t)) {
        return Q_ERR_FILE_TOO_SMALL;
    }
 
    pcx = (dpcx_t *)rawdata;
 
    if (pcx->manufacturer != 10 || pcx->version != 5) {
        return Q_ERR_UNKNOWN_FORMAT;
    }
 
    if (pcx->encoding != 1 || pcx->bits_per_pixel != 8) {
        return Q_ERR_INVALID_FORMAT;
    }
 
    w = (LittleShort(pcx->xmax) - LittleShort(pcx->xmin)) + 1;
    h = (LittleShort(pcx->ymax) - LittleShort(pcx->ymin)) + 1;
    if (w < 1 || h < 1 || w > 640 || h > 480) {
        return Q_ERR_INVALID_FORMAT;
    }
 
    if (pcx->color_planes != 1) {
        return Q_ERR_INVALID_FORMAT;
    }
 
    scan = LittleShort(pcx->bytes_per_line);
    if (scan < w) {
        return Q_ERR_INVALID_FORMAT;
    }
 
    //
    // get palette
    //
    if (palette) {
        if (rawlen < 768) {
            return Q_ERR_FILE_TOO_SMALL;
        }
        memcpy(palette, (byte *)pcx + rawlen - 768, 768);
    }
 
    //
    // get pixels
    //
    if (pixels) {
        raw = pcx->data;
        end = (byte *)pcx + rawlen;
        for (y = 0; y < h; y++, pixels += w) {
            for (x = 0; x < scan;) {
                if (raw >= end)
                    return Q_ERR_BAD_RLE_PACKET;
                dataByte = *raw++;
 
                if ((dataByte & 0xC0) == 0xC0) {
                    runLength = dataByte & 0x3F;
                    if (x + runLength > scan)
                        return Q_ERR_BAD_RLE_PACKET;
                    if (raw >= end)
                        return Q_ERR_BAD_RLE_PACKET;
                    dataByte = *raw++;
                } else {
                    runLength = 1;
                }
 
                while (runLength--) {
                    if (x < w)
                        pixels[x] = dataByte;
                    x++;
                }
            }
        }
    }
 
    if (width)
        *width = w;
    if (height)
        *height = h;
 
    return Q_ERR_SUCCESS;
}

Referenced by IMG_GetPalette(), and IMG_LOAD().

IMG_Find()

image_t* IMG_Find	(	const char *	name,
		imagetype_t	type,
		imageflags_t	flags
	)

Definition at line 1122 of file images.c.

{
    image_t *image;
    size_t len;
    qerror_t ret;
 
    if (!name) {
        Com_Error(ERR_FATAL, "%s: NULL", __func__);
    }
 
    // this should never happen
    len = strlen(name);
    if (len >= MAX_QPATH) {
        Com_Error(ERR_FATAL, "%s: oversize name", __func__);
    }
 
    ret = find_or_load_image(name, len, type, flags, &image);
    if (image) {
        return image;
    }
 
    // don't spam about missing images
    if (ret != Q_ERR_NOENT) {
        Com_EPrintf("Couldn't load %s: %s\n", name, Q_ErrorString(ret));
    }
 
    return R_NOTEXTURE;
}

Referenced by bsp_mesh_register_textures(), GL_LoadWorld(), MOD_LoadMD2(), MOD_LoadMD2_GL(), MOD_LoadMD2_RTX(), MOD_LoadSP2(), ProcessTexinfo(), R_SetSky(), R_SetSky_GL(), R_SetSky_RTX(), vkpt_initialize_all(), vkpt_physical_sky_endRegistration(), and vkpt_textures_prefetch().

IMG_FloodFill()

static void IMG_FloodFill ( byte *  skin, int  skinwidth, int  skinheight  )

static

Definition at line 87 of file images.c.

{
    byte                fillcolor = *skin; // assume this is the pixel to fill
    floodfill_t         fifo[FLOODFILL_FIFO_SIZE];
    int                 inpt = 0, outpt = 0;
    int                 filledcolor = 0; // FIXME: fixed black
 
    // can't fill to filled color or to transparent color
    // (used as visited marker)
    if (fillcolor == filledcolor || fillcolor == 255) {
        return;
    }
 
    fifo[inpt].x = 0, fifo[inpt].y = 0;
    inpt = (inpt + 1) & FLOODFILL_FIFO_MASK;
 
    while (outpt != inpt) {
        int         x = fifo[outpt].x, y = fifo[outpt].y;
        int         fdc = filledcolor;
        byte        *pos = &skin[x + skinwidth * y];
 
        outpt = (outpt + 1) & FLOODFILL_FIFO_MASK;
 
        if (x > 0) FLOODFILL_STEP(-1, -1, 0);
        if (x < skinwidth - 1) FLOODFILL_STEP(1, 1, 0);
        if (y > 0) FLOODFILL_STEP(-skinwidth, 0, -1);
        if (y < skinheight - 1) FLOODFILL_STEP(skinwidth, 0, 1);
 
        skin[x + skinwidth * y] = fdc;
    }
}

Referenced by IMG_LOAD().

IMG_ForHandle()

image_t* IMG_ForHandle

(

qhandle_t

h

)

Definition at line 1156 of file images.c.

{
    if (h < 0 || h >= r_numImages) {
        Com_Error(ERR_FATAL, "%s: %d out of range", __func__, h);
    }
 
    return &r_images[h];
}

Referenced by get_mesh_material(), R_AliasSetupSkin(), R_DrawChar(), R_DrawChar_GL(), R_DrawPic(), R_DrawPic_GL(), R_DrawPic_RTX(), R_DrawStretchPic(), R_DrawStretchPic_GL(), R_DrawString(), R_DrawString_GL(), R_GetPicSize(), R_TileClear(), R_TileClear_GL(), SCR_DrawActive(), and texnum_for_mesh().

IMG_FreeAll()

void IMG_FreeAll

(

void

)

Definition at line 1343 of file images.c.

{
    image_t *image;
    int i, count = 0;
 
    for (i = 1, image = r_images + 1; i < r_numImages; i++, image++) {
        if (!image->registration_sequence)
            continue;        // free image_t slot
        // free it
        IMG_Unload(image);
 
        memset(image, 0, sizeof(*image));
        count++;
    }
 
    if (count) {
        Com_DPrintf("%s: %i images freed\n", __func__, count);
    }
 
    for (i = 0; i < RIMAGES_HASH; i++) {
        List_Init(&r_imageHash[i]);
    }
 
    // &r_images[0] == R_NOTEXTURE
    r_numImages = 1;
}

Referenced by GL_ShutdownImages(), R_Shutdown_RTX(), and R_ShutdownImages().

IMG_FreeUnused()

void IMG_FreeUnused

(

void

)

Definition at line 1310 of file images.c.

{
    image_t *image;
    int i, count = 0;
 
    for (i = 1, image = r_images + 1; i < r_numImages; i++, image++) {
        if (image->registration_sequence == registration_sequence) {
#if USE_REF == REF_SOFT
            // TODO: account for MIPSIZE, TEX_BYTES
            Com_PageInMemory(image->pixels[0], image->upload_width * image->upload_height * 4);
#endif
            continue;        // used this sequence
        }
        if (!image->registration_sequence)
            continue;        // free image_t slot
        if (image->flags & (IF_PERMANENT | IF_SCRAP))
            continue;        // don't free pics
 
        // delete it from hash table
        List_Remove(&image->entry);
 
        // free it
        IMG_Unload(image);
 
        memset(image, 0, sizeof(*image));
        count++;
    }
 
    if (count) {
        Com_DPrintf("%s: %i images freed\n", __func__, count);
    }
}

Referenced by R_EndRegistration(), R_EndRegistration_GL(), R_EndRegistration_RTX(), and R_UnregisterImage().

IMG_GetPalette()

void IMG_GetPalette

(

void

)

Definition at line 1376 of file images.c.

{
    byte        pal[768], *src, *data;
    qerror_t    ret;
    ssize_t     len;
    int         i;
 
    // get the palette
    len = FS_LoadFile(R_COLORMAP_PCX, (void **)&data);
    if (!data) {
        ret = len;
        goto fail;
    }
 
    ret = IMG_DecodePCX(data, len, NULL, pal, NULL, NULL);
 
    FS_FreeFile(data);
 
    if (ret < 0) {
        goto fail;
    }
 
    for (i = 0, src = pal; i < 255; i++, src += 3) {
        d_8to24table[i] = MakeColor(src[0], src[1], src[2], 255);
    }
 
    // 255 is transparent
    d_8to24table[i] = MakeColor(src[0], src[1], src[2], 0);
    return;
 
fail:
    Com_Error(ERR_FATAL, "Couldn't load %s: %s", R_COLORMAP_PCX, Q_ErrorString(ret));
}

Referenced by GL_InitImages(), R_Init_RTX(), and R_InitImages().

IMG_Init()

void IMG_Init

(

void

)

Definition at line 1419 of file images.c.

{
    int i;
 
    if (r_numImages) {
        Com_Error(ERR_FATAL, "%s: %d images not freed", __func__, r_numImages);
    }
 
 
    r_override_textures = Cvar_Get("r_override_textures", "1", CVAR_FILES);
    r_texture_formats = Cvar_Get("r_texture_formats", "pjt", 0);
    r_texture_formats->changed = r_texture_formats_changed;
    r_texture_formats_changed(r_texture_formats);
 
    r_screenshot_format = Cvar_Get("gl_screenshot_format", "jpg", 0);
    r_screenshot_format = Cvar_Get("gl_screenshot_format", "png", 0);
    r_screenshot_quality = Cvar_Get("gl_screenshot_quality", "100", 0);
    r_screenshot_compression = Cvar_Get("gl_screenshot_compression", "6", 0);
 
    Cmd_Register(img_cmd);
 
    for (i = 0; i < RIMAGES_HASH; i++) {
        List_Init(&r_imageHash[i]);
    }
 
    // &r_images[0] == R_NOTEXTURE
    r_numImages = 1;
}

Referenced by GL_InitImages(), R_Init(), and R_Init_RTX().

IMG_List_f()

static void IMG_List_f ( void  )

static

Definition at line 678 of file images.c.

{
    int        i;
    image_t    *image;
    int        texels, count;
 
    if (Cmd_Argc() > 1) {
 
        // save to file
        char path[MAX_OSPATH];
 
        qhandle_t f = FS_EasyOpenFile(path, sizeof(path), FS_MODE_WRITE | FS_FLAG_TEXT, "", Cmd_Argv(1), ".csv");
        if (!f) {
            Com_EPrintf("Error opening '%s'\n", path);
            return;
        }
 
        for (i = 1, count = 0, image = r_images + 1; i < r_numImages; i++, image++) {
 
            if (!image->registration_sequence)
                continue;
 
            char fmt[MAX_QPATH];
            sprintf(fmt, "%%-%ds, %%-%ds, (%% 5d %% 5d), sRGB:%%d\n", MAX_QPATH, MAX_QPATH);
 
            FS_FPrintf(f, fmt, 
                image->name, 
                image->filepath, 
                image->width, 
                image->height,
                image->is_srgb);
        }
        FS_FCloseFile(f);
 
        Com_Printf("Saved '%s'\n", path);
 
    } else {
 
        // dump to console
        static const char types[8] = "PFMSWY??";
 
        Com_Printf("------------------\n");
        texels = count = 0;
 
        for (i = 1, image = r_images + 1; i < r_numImages; i++, image++) {
            if (!image->registration_sequence)
                continue;
 
            Com_Printf("%c%c%c%c %4i %4i %s: %s\n",
                types[image->type > IT_MAX ? IT_MAX : image->type],
                (image->flags & IF_TRANSPARENT) ? 'T' : ' ',
                (image->flags & IF_SCRAP) ? 'S' : ' ',
                (image->flags & IF_PERMANENT) ? '*' : ' ',
                image->upload_width,
                image->upload_height,
                (image->flags & IF_PALETTED) ? "PAL" : "RGB",
                image->name);
 
            texels += image->upload_width * image->upload_height;
            count++;
        }
        Com_Printf("Total images: %d (out of %d slots)\n", count, r_numImages);
        Com_Printf("Total texels: %d (not counting mipmaps)\n", texels);
    }
}

IMG_LOAD() [1/3]

IMG_LOAD

(

PCX

)

Definition at line 268 of file images.c.

{
    byte        buffer[640 * 480];
    int         w, h;
    qerror_t    ret;
 
    ret = IMG_DecodePCX(rawdata, rawlen, buffer, NULL, &w, &h);
    if (ret < 0)
        return ret;
 
    if (image->type == IT_SKIN)
        IMG_FloodFill(buffer, w, h);
 
    *pic = IMG_AllocPixels(w * h * 4);
 
    image->upload_width = image->width = w;
    image->upload_height = image->height = h;
    image->flags |= IMG_Unpack8((uint32_t *)*pic, buffer, w, h);
 
    return Q_ERR_SUCCESS;
}

IMG_LOAD() [2/3]

IMG_LOAD

(

STB

)

Definition at line 341 of file images.c.

{
    int w, h, channels;
    byte* data = stbi_load_from_memory(rawdata, rawlen, &w, &h, &channels, 4);
 
    if (!data)
        return Q_ERR_LIBRARY_ERROR;
 
    *pic = data;
 
    image->upload_width = image->width = w;
    image->upload_height = image->height = h;
 
    if (channels == 3)
        image->flags |= IF_OPAQUE;
 
    return Q_ERR_SUCCESS;
}

IMG_LOAD() [3/3]

IMG_LOAD

(

WAL

)

Definition at line 299 of file images.c.

{
    miptex_t    *mt;
    size_t      w, h, offset, size, endpos;
 
    if (rawlen < sizeof(miptex_t)) {
        return Q_ERR_FILE_TOO_SMALL;
    }
 
    mt = (miptex_t *)rawdata;
 
    w = LittleLong(mt->width);
    h = LittleLong(mt->height);
    if (w < 1 || h < 1 || w > 512 || h > 512) {
        return Q_ERR_INVALID_FORMAT;
    }
 
    size = w * h;
 
    offset = LittleLong(mt->offsets[0]);
    endpos = offset + size;
    if (endpos < offset || endpos > rawlen) {
        return Q_ERR_BAD_EXTENT;
    }
 
    *pic = IMG_AllocPixels(size * 4);
 
    image->upload_width = image->width = w;
    image->upload_height = image->height = h;
    image->flags |= IMG_Unpack8((uint32_t *)*pic, (uint8_t *)mt + offset, w, h);
 
    return Q_ERR_SUCCESS;
}

IMG_MipMap()

void IMG_MipMap	(	byte *	out,
		byte *	in,
		int	width,
		int	height
	)

Definition at line 623 of file images.c.

{
    int     i, j;
 
    width <<= 2;
    height >>= 1;
    for (i = 0; i < height; i++, in += width) {
        for (j = 0; j < width; j += 8, out += 4, in += 8) {
            out[0] = (in[0] + in[4] + in[width + 0] + in[width + 4]) >> 2;
            out[1] = (in[1] + in[5] + in[width + 1] + in[width + 5]) >> 2;
            out[2] = (in[2] + in[6] + in[width + 2] + in[width + 6]) >> 2;
            out[3] = (in[3] + in[7] + in[width + 3] + in[width + 7]) >> 2;
        }
    }
}

Referenced by GL_Upload32(), and IMG_Load().

IMG_ResampleTexture()

void IMG_ResampleTexture	(	const byte *	in,
		int	inwidth,
		int	inheight,
		byte *	out,
		int	outwidth,
		int	outheight
	)

Definition at line 577 of file images.c.

{
    int i, j;
    const byte  *inrow1, *inrow2;
    unsigned    frac, fracstep;
    unsigned    p1[MAX_TEXTURE_SIZE], p2[MAX_TEXTURE_SIZE];
    const byte  *pix1, *pix2, *pix3, *pix4;
    float       heightScale;
 
    if (outwidth > MAX_TEXTURE_SIZE) {
        Com_Error(ERR_FATAL, "%s: outwidth > %d", __func__, MAX_TEXTURE_SIZE);
    }
 
    fracstep = inwidth * 0x10000 / outwidth;
 
    frac = fracstep >> 2;
    for (i = 0; i < outwidth; i++) {
        p1[i] = 4 * (frac >> 16);
        frac += fracstep;
    }
    frac = 3 * (fracstep >> 2);
    for (i = 0; i < outwidth; i++) {
        p2[i] = 4 * (frac >> 16);
        frac += fracstep;
    }
 
    heightScale = (float)inheight / outheight;
    inwidth <<= 2;
    for (i = 0; i < outheight; i++) {
        inrow1 = in + inwidth * (int)((i + 0.25f) * heightScale);
        inrow2 = in + inwidth * (int)((i + 0.75f) * heightScale);
        for (j = 0; j < outwidth; j++) {
            pix1 = inrow1 + p1[j];
            pix2 = inrow1 + p2[j];
            pix3 = inrow2 + p1[j];
            pix4 = inrow2 + p2[j];
            out[0] = (pix1[0] + pix2[0] + pix3[0] + pix4[0]) >> 2;
            out[1] = (pix1[1] + pix2[1] + pix3[1] + pix4[1]) >> 2;
            out[2] = (pix1[2] + pix2[2] + pix3[2] + pix4[2]) >> 2;
            out[3] = (pix1[3] + pix2[3] + pix3[3] + pix4[3]) >> 2;
            out += 4;
        }
    }
}

Referenced by GL_Upload32(), and IMG_Load().

IMG_SAVE() [1/3]

IMG_SAVE

(

JPG

)

Definition at line 380 of file images.c.

{
    stbi_flip_vertically_on_write(1);
    int ret = stbi_write_jpg_to_func(stbi_write, (void*)(size_t)f, width, height, 3, pic, param);
 
    if (ret)
        return Q_ERR_SUCCESS;
 
    return Q_ERR_LIBRARY_ERROR;
}

IMG_SAVE() [2/3]

IMG_SAVE

(

PNG

)

Definition at line 392 of file images.c.

{
    stbi_flip_vertically_on_write(1);
    int ret = stbi_write_png_to_func(stbi_write, (void*)(size_t)f, width, height, 3, pic, row_stride);
 
    if (ret)
        return Q_ERR_SUCCESS;
 
    return Q_ERR_LIBRARY_ERROR;
}

IMG_SAVE() [3/3]

IMG_SAVE

(

TGA

)

Definition at line 369 of file images.c.

{
    stbi_flip_vertically_on_write(1);
    int ret = stbi_write_tga_to_func(stbi_write, (void*)(size_t)f, width, height, 3, pic);
 
    if (ret) 
        return Q_ERR_SUCCESS;
 
    return Q_ERR_LIBRARY_ERROR;
}

IMG_ScreenShot_f()

static void IMG_ScreenShot_f ( void  )

static

Definition at line 484 of file images.c.

{
    const char *s;
 
    if (Cmd_Argc() > 2) {
        Com_Printf("Usage: %s [format]\n", Cmd_Argv(0));
        return;
    }
 
    if (Cmd_Argc() > 1) {
        s = Cmd_Argv(1);
    } else {
        s = r_screenshot_format->string;
    }
 
    if (*s == 'j') {
        make_screenshot(NULL, ".jpg", IMG_SaveJPG,
                        r_screenshot_quality->integer);
        return;
    }
 
    if (*s == 'p') {
        make_screenshot(NULL, ".png", IMG_SavePNG,
                        r_screenshot_compression->integer);
        return;
    }
 
    make_screenshot(NULL, ".tga", IMG_SaveTGA, 0);
}

IMG_ScreenShotJPG_f()

static void IMG_ScreenShotJPG_f ( void  )

static

Definition at line 533 of file images.c.

{
    int quality;
 
    if (Cmd_Argc() > 3) {
        Com_Printf("Usage: %s [name] [quality]\n", Cmd_Argv(0));
        return;
    }
 
    if (Cmd_Argc() > 2) {
        quality = atoi(Cmd_Argv(2));
    } else {
        quality = r_screenshot_quality->integer;
    }
 
    make_screenshot(Cmd_Argv(1), ".jpg", IMG_SaveJPG, quality);
}

IMG_ScreenShotPNG_f()

static void IMG_ScreenShotPNG_f ( void  )

static

Definition at line 551 of file images.c.

{
    int compression;
 
    if (Cmd_Argc() > 3) {
        Com_Printf("Usage: %s [name] [compression]\n", Cmd_Argv(0));
        return;
    }
 
    if (Cmd_Argc() > 2) {
        compression = atoi(Cmd_Argv(2));
    } else {
        compression = r_screenshot_compression->integer;
    }
 
    make_screenshot(Cmd_Argv(1), ".png", IMG_SavePNG, compression);
}

IMG_ScreenShotTGA_f()

static void IMG_ScreenShotTGA_f ( void  )

static

Definition at line 523 of file images.c.

{
    if (Cmd_Argc() > 2) {
        Com_Printf("Usage: %s [name]\n", Cmd_Argv(0));
        return;
    }
 
    make_screenshot(Cmd_Argv(1), ".tga", IMG_SaveTGA, 0);
}

IMG_Shutdown()

void IMG_Shutdown

(

void

)

Definition at line 1448 of file images.c.

{
    Cmd_Deregister(img_cmd);
    r_numImages = 0;
}

Referenced by GL_ShutdownImages(), R_Shutdown(), and R_Shutdown_RTX().

IMG_Unpack8()

static int IMG_Unpack8 ( uint32_t *  out, const uint8_t *  in, int  width, int  height  )

static

Definition at line 222 of file images.c.

{
    int         x, y, p;
    qboolean    has_alpha = qfalse;
 
    for (y = 0; y < height; y++) {
        for (x = 0; x < width; x++) {
            p = *in;
            if (p == 255) {
                has_alpha = qtrue;
                // transparent, so scan around for another color
                // to avoid alpha fringes
                if (y > 0 && *(in - width) != 255)
                    p = *(in - width);
                else if (y < height - 1 && *(in + width) != 255)
                    p = *(in + width);
                else if (x > 0 && *(in - 1) != 255)
                    p = *(in - 1);
                else if (x < width - 1 && *(in + 1) != 255)
                    p = *(in + 1);
                else if (y > 0 && x > 0 && *(in - width - 1) != 255)
                    p = *(in - width - 1);
                else if (y > 0 && x < width - 1 && *(in - width + 1) != 255)
                    p = *(in - width + 1);
                else if (y < height - 1 && x > 0 && *(in + width - 1) != 255)
                    p = *(in + width - 1);
                else if (y < height - 1 && x < width - 1 && *(in + width + 1) != 255)
                    p = *(in + width + 1);
                else
                    p = 0;
                // copy rgb components
                *out = d_8to24table[p] & U32_RGB;
            } else {
                *out = d_8to24table[p];
            }
            in++;
            out++;
        }
    }
 
    if (has_alpha)
        return IF_PALETTED | IF_TRANSPARENT;
 
    return IF_PALETTED | IF_OPAQUE;
}

Referenced by IMG_LOAD().

load_img()

qerror_t load_img	(	const char *	name,
		image_t *	image
	)

Definition at line 927 of file images.c.

{
    byte            *pic;
    imageformat_t   fmt;
    qerror_t        ret;
 
    size_t len = strlen(name);
 
    // must have an extension and at least 1 char of base name
    if (len <= 4) {
        return Q_ERR_NAMETOOSHORT;
    }
    if (name[len - 4] != '.') {
        return Q_ERR_INVALID_PATH;
    }
 
    memcpy(image->name, name, len + 1);
    image->baselen = len - 4;
    image->type = 0;
    image->flags = 0;
    image->registration_sequence = 1;
 
    // find out original extension
    for (fmt = 0; fmt < IM_MAX; fmt++) {
        if (!Q_stricmp(image->name + image->baselen + 1, img_loaders[fmt].ext)) {
            break;
        }
    }
 
    // load the pic from disk
    pic = NULL;
 
    // first try with original extension
    ret = _try_image_format(fmt, image, &pic);
    if (ret == Q_ERR_NOENT) {
        // retry with remaining extensions
        ret = try_other_formats(fmt, image, &pic);
    }
 
    // if we are replacing 8-bit texture with a higher resolution 32-bit
    // texture, we need to recover original image dimensions
    if (fmt <= IM_WAL && ret > IM_WAL) {
        get_image_dimensions(fmt, image);
    }
 
    // if we are replacing 8-bit texture with a higher resolution 32-bit
    // texture, we need to recover original image dimensions
    if (fmt <= IM_WAL && ret > IM_WAL) {
        get_image_dimensions(fmt, image);
    }
 
    if (ret < 0) {
        memset(image, 0, sizeof(*image));
        return ret;
    }
 
#if USE_REF == REF_VKPT
    image->pix_data = pic;
#endif
 
    return Q_ERR_SUCCESS;
}

Referenced by IMG_ReloadAll().

lookup_image()

static image_t* lookup_image ( const char *  name, imagetype_t  type, unsigned  hash, size_t  baselen  )

static

Definition at line 766 of file images.c.

{
    image_t *image;
 
    // look for it
    LIST_FOR_EACH(image_t, image, &r_imageHash[hash], entry) {
        if (image->type != type) {
            continue;
        }
        if (image->baselen != baselen) {
            continue;
        }
        if (!FS_pathcmpn(image->name, name, baselen)) {
            return image;
        }
    }
 
    return NULL;
}

Referenced by find_or_load_image(), and R_RegisterRawImage().

make_screenshot()

static void make_screenshot ( const char *  name, const char *  ext, qerror_t(*)(qhandle_t, const char *, byte *, int, int, int, int)  save, int  param  )

static

Definition at line 446 of file images.c.

{
    char        buffer[MAX_OSPATH];
    byte        *pixels;
    qerror_t    ret;
    qhandle_t   f;
    int         w, h, rowbytes;
 
    f = create_screenshot(buffer, sizeof(buffer), name, ext);
    if (!f) {
        return;
    }
 
    pixels = IMG_ReadPixels(&w, &h, &rowbytes);
    ret = save(f, buffer, pixels, w, h, rowbytes, param);
    FS_FreeTempMem(pixels);
 
    FS_FCloseFile(f);
 
    if (ret < 0) {
        Com_EPrintf("Couldn't write %s: %s\n", buffer, Q_ErrorString(ret));
    } else {
        Com_Printf("Wrote %s\n", buffer);
    }
}

Referenced by IMG_ScreenShot_f(), IMG_ScreenShotJPG_f(), IMG_ScreenShotPNG_f(), and IMG_ScreenShotTGA_f().

R_GetPicSize()

qboolean R_GetPicSize	(	int *	w,
		int *	h,
		qhandle_t	pic
	)

Definition at line 1289 of file images.c.

{
    image_t *image = IMG_ForHandle(pic);
 
    if (w) {
        *w = image->width;
    }
    if (h) {
        *h = image->height;
    }
    return !!(image->flags & IF_TRANSPARENT);
}

Referenced by Parse_Background(), Parse_Banner(), Parse_Bitmap(), Parse_File(), Parse_Footer(), Parse_Plaque(), Push(), scr_crosshair_changed(), SCR_RegisterMedia(), and UI_Init().

R_RegisterImage()

qhandle_t R_RegisterImage	(	const char *	name,
		imagetype_t	type,
		imageflags_t	flags,
		qerror_t *	err_p
	)

Definition at line 1170 of file images.c.

{
    image_t     *image;
    char        fullname[MAX_QPATH];
    size_t      len;
    qerror_t    err;
 
    // empty names are legal, silently ignore them
    if (!*name) {
        if (err_p)
            *err_p = Q_ERR_NAMETOOSHORT;
        return 0;
    }
 
    // no images = not initialized
    if (!r_numImages) {
        if (err_p)
            *err_p = Q_ERR_AGAIN;
        return 0;
    }
 
    if (type == IT_SKIN) {
        len = FS_NormalizePathBuffer(fullname, name, sizeof(fullname));
    } else if (*name == '/' || *name == '\\') {
        len = FS_NormalizePathBuffer(fullname, name + 1, sizeof(fullname));
    } else {
        len = Q_concat(fullname, sizeof(fullname), "pics/", name, NULL);
        if (len >= sizeof(fullname)) {
            err = Q_ERR_NAMETOOLONG;
            goto fail;
        }
        FS_NormalizePath(fullname, fullname);
        len = COM_DefaultExtension(fullname, ".pcx", sizeof(fullname));
    }
 
    if (len >= sizeof(fullname)) {
        err = Q_ERR_NAMETOOLONG;
        goto fail;
    }
 
    err = find_or_load_image(fullname, len, type, flags, &image);
    if (image) {
        if (err_p)
            *err_p = Q_ERR_SUCCESS;
        return image - r_images;
    }
 
fail:
    // don't spam about missing images
    if (err_p)
        *err_p = err;
    else if (err != Q_ERR_NOENT)
        Com_EPrintf("Couldn't load %s: %s\n", fullname, Q_ErrorString(err));
 
    return 0;
}

Referenced by Con_RegisterMedia(), and SCR_RegisterMedia().

R_RegisterRawImage()

qhandle_t R_RegisterRawImage	(	const char *	name,
		int	width,
		int	height,
		byte *	pic,
		imagetype_t	type,
		imageflags_t	flags
	)

Definition at line 1228 of file images.c.

{
    image_t         *image;
    unsigned        hash;
 
    int len = strlen(name);
    hash = FS_HashPathLen(name, len, RIMAGES_HASH);
 
    // look for it
    if ((image = lookup_image(name, type, hash, len)) != NULL) {
        image->flags |= flags & IF_PERMANENT;
        image->registration_sequence = registration_sequence;
        return image - r_images;
    }
 
    // allocate image slot
    image = alloc_image();
    if (!image) {
        return 0;
    }
 
    memcpy(image->name, name, len + 1);
    image->baselen = len;
    image->type = type;
    image->flags = flags;
    image->registration_sequence = registration_sequence;
    image->last_modified = 0;
    image->width = width;
    image->height = height;
    image->upload_width = width;
    image->upload_height = height;
 
    List_Append(&r_imageHash[hash], &image->entry);
 
    image->is_srgb = !!(flags & IF_SRGB);
 
    // upload the image
    IMG_Load(image, pic);
 
    return image - r_images;
}

Referenced by SCR_ReadNextFrame().

r_texture_formats_changed()

static void r_texture_formats_changed ( cvar_t *  self )

static

Definition at line 895 of file images.c.

{
    char *s;
    int i, j;
 
    // reset the search order
    img_total = 0;
 
    // parse the string
    for (s = self->string; *s; s++) {
        switch (*s) {
            case 't': case 'T': i = IM_TGA; break;
            case 'j': case 'J': i = IM_JPG; break;
            case 'p': case 'P': i = IM_PNG; break;
            default: continue;
        }
 
        // don't let format to be specified more than once
        for (j = 0; j < img_total; j++)
            if (img_search[j] == i)
                break;
        if (j != img_total)
            continue;
 
        img_search[img_total++] = i;
        if (img_total == IM_MAX) {
            break;
        }
    }
}

Referenced by IMG_Init().

R_UnregisterImage()

void R_UnregisterImage

(

qhandle_t

handle

)

Definition at line 1270 of file images.c.

{
    if (!handle)
        return;
 
    image_t* image = r_images + handle;
 
    if (image->registration_sequence)
    {
        image->registration_sequence = -1;
        IMG_FreeUnused();
    }
}

Referenced by SCR_RunCinematic(), and SCR_StopCinematic().

stbi_write()

void stbi_write	(	void *	context,
		void *	data,
		int	size
	)

Definition at line 45 of file images.c.

{
    FS_Write(data, size, (qhandle_t)(size_t)context);
}

Referenced by IMG_SAVE().

try_image_format()

static int try_image_format ( imageformat_t  fmt, image_t *  image, byte **  pic  )

static

Definition at line 814 of file images.c.

{
    // replace the extension
    memcpy(image->name + image->baselen + 1, img_loaders[fmt].ext, 4);
    return _try_image_format(fmt, image, pic);
}

Referenced by try_other_formats().

try_other_formats()

static int try_other_formats ( imageformat_t  orig, image_t *  image, byte **  pic  )

static

Definition at line 823 of file images.c.

{
    imageformat_t   fmt;
    qerror_t        ret;
    int             i;
 
    // search through all the 32-bit formats
    for (i = 0; i < img_total; i++) {
        fmt = img_search[i];
        if (fmt == orig) {
            continue;   // don't retry twice
        }
 
        ret = try_image_format(fmt, image, pic);
        if (ret != Q_ERR_NOENT) {
            return ret; // found something
        }
    }
 
    // fall back to 8-bit formats
    fmt = (image->type == IT_WALL) ? IM_WAL : IM_PCX;
    if (fmt == orig) {
        return Q_ERR_NOENT; // don't retry twice
    }
 
    return try_image_format(fmt, image, pic);
}

Referenced by find_or_load_image(), and load_img().

Variable Documentation

d_8to24table

uint32_t d_8to24table[256]

Definition at line 654 of file images.c.

Referenced by cast_u32_to_f32_color(), CL_RailTrail(), GL_DrawBeams(), GL_DrawParticles(), IMG_GetPalette(), IMG_Unpack8(), R_AliasSetupBlend(), R_DrawBeam(), R_DrawFill8(), R_DrawFill8_GL(), R_DrawFill8_RTX(), R_DrawParticles(), and SCR_ReadNextFrame().

ext

char ext[4]

Definition at line 657 of file images.c.

Referenced by check_and_queue_download(), check_file_len(), CL_CheckDownloadExtension(), COM_DefaultExtension(), create_screenshot(), easy_open_read(), easy_open_write(), FS_Dir_f(), FS_EasyOpenFile(), FS_EasyWriteFile(), FS_ExtCmp(), FS_File_g(), get_vk_extension_list(), get_vk_layer_list(), init_vulkan(), make_screenshot(), and print_file_list().

img_cmd

const cmdreg_t img_cmd[]

static

Initial value:

= {
    { "imagelist", IMG_List_f },
    { "screenshot", IMG_ScreenShot_f },
    { "screenshottga", IMG_ScreenShotTGA_f },
    { "screenshotjpg", IMG_ScreenShotJPG_f },
    { "screenshotpng", IMG_ScreenShotPNG_f },
    { NULL }
}

Definition at line 1410 of file images.c.

Referenced by IMG_Init(), and IMG_Shutdown().

img_loaders

const { ... } img_loaders[IM_MAX]

Initial value:

= {
    { "pcx", IMG_LoadPCX },
    { "wal", IMG_LoadWAL },
    { "tga", IMG_LoadSTB },
    { "jpg", IMG_LoadSTB },
    { "png", IMG_LoadSTB }
}

Referenced by _try_image_format(), find_or_load_image(), load_img(), and try_image_format().

img_search

imageformat_t img_search[IM_MAX]

static

Definition at line 667 of file images.c.

Referenced by r_texture_formats_changed(), and try_other_formats().

img_total

int img_total

static

Definition at line 668 of file images.c.

Referenced by r_texture_formats_changed(), and try_other_formats().

load

qerror_t(* load) (byte *, size_t, image_t *, byte **)

Definition at line 658 of file images.c.

Referenced by R_RegisterModel().

r_imageHash

list_t r_imageHash[RIMAGES_HASH]

static

Definition at line 649 of file images.c.

Referenced by find_or_load_image(), IMG_FreeAll(), IMG_Init(), lookup_image(), and R_RegisterRawImage().

r_images

image_t r_images[MAX_RIMAGES]

Definition at line 651 of file images.c.

Referenced by alloc_image(), enqueue_stretch_pic(), gl_anisotropy_changed(), gl_bilerp_chars_changed(), gl_bilerp_pics_changed(), gl_texturemode_changed(), IMG_ForHandle(), IMG_FreeAll(), IMG_FreeUnused(), IMG_List_f(), IMG_ReloadAll(), IMG_Unload_RTX(), prepare_ubo(), R_RegisterImage(), R_RegisterRawImage(), R_UnregisterImage(), vkpt_light_buffer_upload_to_staging(), vkpt_physical_sky_endRegistration(), vkpt_textures_end_registration(), vkpt_textures_update_descriptor_set(), and write_sprite_geometry().

r_numImages

int r_numImages

Definition at line 652 of file images.c.

Referenced by alloc_image(), gl_anisotropy_changed(), gl_bilerp_chars_changed(), gl_bilerp_pics_changed(), gl_texturemode_changed(), IMG_ForHandle(), IMG_FreeAll(), IMG_FreeUnused(), IMG_Init(), IMG_List_f(), IMG_ReloadAll(), IMG_Shutdown(), and R_RegisterImage().

r_override_textures

cvar_t* r_override_textures

static

Definition at line 670 of file images.c.

Referenced by find_or_load_image(), and IMG_Init().

r_screenshot_compression

cvar_t* r_screenshot_compression

static

Definition at line 413 of file images.c.

Referenced by IMG_Init(), IMG_ScreenShot_f(), and IMG_ScreenShotPNG_f().

r_screenshot_format

cvar_t* r_screenshot_format

static

Definition at line 411 of file images.c.

Referenced by IMG_Init(), and IMG_ScreenShot_f().

r_screenshot_quality

cvar_t* r_screenshot_quality

static

Definition at line 412 of file images.c.

Referenced by IMG_Init(), IMG_ScreenShot_f(), and IMG_ScreenShotJPG_f().

r_texture_formats

cvar_t* r_texture_formats

static

Definition at line 671 of file images.c.

Referenced by IMG_Init().

vid_rtx

cvar_t* vid_rtx

Definition at line 30 of file refresh.c.

Referenced by find_or_load_image().