blendo/thirtyflightsofloving
0
0
Fork 0
mirror of https://github.com/blendogames/thirtyflightsofloving.git synced 2024-11-14 00:21:18 +00:00
Code Issues Projects Releases Packages Wiki Activity
thirtyflightsofloving/renderer/r_image.c
Knightmare66 befa8db495 Added GL_PrintError() for more detailed OpenGL error output. 
Added R_EndFrame() to remove direct calls to GLimp_EndFrame() from client and UI.
Removed GL_LockArrays()/GL_UnlockArrays() calls in shadow volume rendering.
Changed parameters to UI_DrawMenuString(), UI_DrawString(), and variants.
Added UI_DrawPopupMessage() to simplify popup text drawing.
2021-11-19 07:25:37 -05:00

2788 lines
67 KiB
C
Raw Permalink Blame History

/*
===========================================================================
Copyright (C) 1997-2001 Id Software, Inc.
This file is part of Quake 2 source code.
Quake 2 source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
Quake 2 source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Quake 2 source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
// r_image.c
#include "r_local.h"
#ifdef _WIN32
#include "../include/jpeg/jpeglib.h"
#ifdef PNG_SUPPORT
#if defined (_MSC_VER) && (_MSC_VER <= 1200) // use older version of libpng for MSVC6
#include "../include/zlibpng_vc6/png.h"
#else
#include "../include/zlibpng/png.h"
#endif
#endif // PNG_SUPPORT
#else // _WIN32
#include <jpeglib.h>
#ifdef PNG_SUPPORT
#include <png.h>
#endif // PNG_SUPPORT
#endif // _WIN32
#ifdef _WIN32 // Let's not use GLU on Linux/macOS -flibit
#define USE_GLU_MIPMAP
#endif // _WIN32
image_t gltextures[MAX_GLTEXTURES];
int numgltextures;
int base_textureid; // gltextures[i] = base_textureid+i
static byte intensitytable[256];
static unsigned char gammatable[256];
cvar_t *r_intensity;
unsigned d_8to24table[256];
float d_8to24tablef[256][3]; // Knightmare- MrG's Vertex array stuff
qboolean GL_Upload8 (byte *data, int width, int height, imagetype_t type);
qboolean GL_Upload32 (unsigned *data, int width, int height, imagetype_t type);
int gl_filter_min;
int gl_filter_max;
#if 0
void GL_SetTexturePalette (unsigned palette[256])
{
int i;
unsigned char temptable[768];
if ( qglColorTableEXT )//&& gl_ext_palettedtexture->value )
{
for ( i = 0; i < 256; i++ )
{
temptable[i*3+0] = ( palette[i] >> 0 ) & 0xff;
temptable[i*3+1] = ( palette[i] >> 8 ) & 0xff;
temptable[i*3+2] = ( palette[i] >> 16 ) & 0xff;
}
qglColorTableEXT( GL_SHARED_TEXTURE_PALETTE_EXT,
GL_RGB,
256,
GL_RGB,
GL_UNSIGNED_BYTE,
temptable );
}
}
#endif
typedef struct
{
char *name;
int minimize, maximize;
} glmode_t;
glmode_t gl_modes[] = {
{"GL_NEAREST", GL_NEAREST, GL_NEAREST},
{"GL_LINEAR", GL_LINEAR, GL_LINEAR},
{"GL_NEAREST_MIPMAP_NEAREST", GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST},
{"GL_LINEAR_MIPMAP_NEAREST", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR},
{"GL_NEAREST_MIPMAP_LINEAR", GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST},
{"GL_LINEAR_MIPMAP_LINEAR", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR}
};
#define NUM_GL_MODES (sizeof(gl_modes) / sizeof (glmode_t))
#if 0 // removed
typedef struct
{
char *name;
int mode;
} gltmode_t;
gltmode_t gl_alpha_modes[] = {
{"default", 4},
{"GL_RGBA", GL_RGBA},
{"GL_RGBA8", GL_RGBA8},
{"GL_RGB5_A1", GL_RGB5_A1},
{"GL_RGBA4", GL_RGBA4},
{"GL_RGBA2", GL_RGBA2},
};
#define NUM_GL_ALPHA_MODES (sizeof(gl_alpha_modes) / sizeof (gltmode_t))
gltmode_t gl_solid_modes[] = {
{"default", 3},
{"GL_RGB", GL_RGB},
{"GL_RGB8", GL_RGB8},
{"GL_RGB5", GL_RGB5},
{"GL_RGB4", GL_RGB4},
{"GL_R3_G3_B2", GL_R3_G3_B2},
#ifdef GL_RGB2_EXT
{"GL_RGB2", GL_RGB2_EXT},
#endif
};
#define NUM_GL_SOLID_MODES (sizeof(gl_solid_modes) / sizeof (gltmode_t))
#endif
/*
===============
GL_UpdateAnisoMode
===============
*/
void GL_UpdateAnisoMode (void)
{
int i;
image_t *glt;
// clamp selected anisotropy
if (glConfig.anisotropic)
{
if (r_anisotropic->value > glConfig.max_anisotropy)
Cvar_SetValue("r_anisotropic", glConfig.max_anisotropy);
else if (r_anisotropic->value < 1.0)
Cvar_SetValue("r_anisotropic", 1.0);
}
// change all the existing mipmap texture objects
for (i=0, glt=gltextures; i<numgltextures; i++, glt++)
{
if ( (glt->type != it_pic) && (glt->type != it_font) && (glt->type != it_scrap) && (glt->type != it_sky) )
{
GL_Bind (glt->texnum);
// Set anisotropic filter if supported and enabled
if (glConfig.anisotropic && r_anisotropic->value)
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, r_anisotropic->value);
}
}
}
/*
===============
GL_TextureMode
===============
*/
void GL_TextureMode (char *string)
{
int i;
image_t *glt;
for (i=0; i< NUM_GL_MODES; i++)
{
if ( !Q_stricmp(gl_modes[i].name, string) )
break;
}
if (i == NUM_GL_MODES)
{
VID_Printf (PRINT_ALL, "bad filter name\n");
return;
}
gl_filter_min = gl_modes[i].minimize;
gl_filter_max = gl_modes[i].maximize;
// clamp selected anisotropy
if (glConfig.anisotropic)
{
if (r_anisotropic->value > glConfig.max_anisotropy)
Cvar_SetValue("r_anisotropic", glConfig.max_anisotropy);
else if (r_anisotropic->value < 1.0)
Cvar_SetValue("r_anisotropic", 1.0);
}
// change all the existing mipmap texture objects
for (i=0, glt=gltextures; i<numgltextures; i++, glt++)
{
if ( (glt->type != it_pic) && (glt->type != it_font) && (glt->type != it_scrap) && (glt->type != it_sky) )
{
GL_Bind (glt->texnum);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
// Set anisotropic filter if supported and enabled
if (glConfig.anisotropic && r_anisotropic->value) {
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, r_anisotropic->value);
}
}
}
}
#if 0 // removed
/*
===============
GL_TextureAlphaMode
===============
*/
void GL_TextureAlphaMode (char *string)
{
int i;
for (i=0 ; i< NUM_GL_ALPHA_MODES ; i++)
{
if ( !Q_stricmp( gl_alpha_modes[i].name, string ) )
break;
}
if (i == NUM_GL_ALPHA_MODES)
{
VID_Printf (PRINT_ALL, "bad alpha texture mode name\n");
return;
}
gl_tex_alpha_format = gl_alpha_modes[i].mode;
}
/*
===============
GL_TextureSolidMode
===============
*/
void GL_TextureSolidMode (char *string)
{
int i;
for (i=0 ; i< NUM_GL_SOLID_MODES ; i++)
{
if ( !Q_stricmp( gl_solid_modes[i].name, string ) )
break;
}
if (i == NUM_GL_SOLID_MODES)
{
VID_Printf (PRINT_ALL, "bad solid texture mode name\n");
return;
}
gl_tex_solid_format = gl_solid_modes[i].mode;
}
#endif
/*
===============
R_ImageList_f
===============
*/
void R_ImageList_f (void)
{
int i;
image_t *image;
int texels;
const char *palstrings[2] =
{
"RGB",
"PAL"
};
VID_Printf (PRINT_ALL, "------------------\n");
texels = 0;
for (i=0, image=gltextures; i<numgltextures; i++, image++)
{
if (image->texnum <= 0)
continue;
texels += image->upload_width*image->upload_height;
switch (image->type)
{
case it_skin:
VID_Printf (PRINT_ALL, "M");
break;
case it_sprite:
VID_Printf (PRINT_ALL, "S");
break;
case it_wall:
VID_Printf (PRINT_ALL, "W");
break;
case it_pic:
VID_Printf (PRINT_ALL, "P");
break;
case it_font:
VID_Printf (PRINT_ALL, "F");
break;
case it_scrap:
VID_Printf (PRINT_ALL, "C");
break;
case it_part:
VID_Printf (PRINT_ALL, "P");
break;
default:
VID_Printf (PRINT_ALL, " ");
break;
}
VID_Printf (PRINT_ALL, " %3i %3i %s: %s\n",
image->upload_width, image->upload_height, palstrings[image->paletted], image->name);
}
VID_Printf (PRINT_ALL, "Total texel count (not counting mipmaps): %i\n", texels);
}
/*
=============================================================================
scrap allocation
Allocate all the little status bar obejcts into a single texture
to crutch up inefficient hardware / drivers
=============================================================================
*/
#define MAX_SCRAPS 1
#define SCRAP_BLOCK_WIDTH 256
#define SCRAP_BLOCK_HEIGHT 256
int scrap_allocated[MAX_SCRAPS][SCRAP_BLOCK_WIDTH];
byte scrap_texels[MAX_SCRAPS][SCRAP_BLOCK_WIDTH*SCRAP_BLOCK_HEIGHT];
qboolean scrap_dirty;
// returns a texture number and the position inside it
int Scrap_AllocBlock (int w, int h, int *x, int *y)
{
int i, j;
int best, best2;
int texnum;
for (texnum=0; texnum<MAX_SCRAPS; texnum++)
{
best = SCRAP_BLOCK_HEIGHT;
for (i=0; i<SCRAP_BLOCK_WIDTH-w; i++)
{
best2 = 0;
for (j=0 ; j<w ; j++)
{
if (scrap_allocated[texnum][i+j] >= best)
break;
if (scrap_allocated[texnum][i+j] > best2)
best2 = scrap_allocated[texnum][i+j];
}
if (j == w)
{ // this is a valid spot
*x = i;
*y = best = best2;
}
}
if (best + h > SCRAP_BLOCK_HEIGHT)
continue;
for (i=0 ; i<w ; i++)
scrap_allocated[texnum][*x + i] = best + h;
return texnum;
}
return -1;
// Sys_Error ("Scrap_AllocBlock: full");
}
int scrap_uploads;
void Scrap_Upload (void)
{
scrap_uploads++;
GL_Bind(TEXNUM_SCRAPS);
GL_Upload8 (scrap_texels[0], SCRAP_BLOCK_WIDTH, SCRAP_BLOCK_HEIGHT, it_scrap); // was it_pic
scrap_dirty = false;
}
/*
=================================================================
PCX LOADING
=================================================================
*/
/*
==============
LoadPCX
==============
*/
void LoadPCX (char *filename, byte **pic, byte **palette, int *width, int *height)
{
byte *raw;
pcx_t *pcx;
int x, y;
int len;
int dataByte, runLength;
byte *out, *pix;
*pic = NULL;
*palette = NULL;
//
// load the file
//
len = FS_LoadFile (filename, (void **)&raw);
if (!raw)
{
// Knightmare- skip this unless developer >= 2 because it spams the console
if (developer->integer > 1)
VID_Printf (PRINT_DEVELOPER, "Bad pcx file %s\n", filename);
return;
}
//
// parse the PCX file
//
pcx = (pcx_t *)raw;
pcx->xmin = LittleShort(pcx->xmin);
pcx->ymin = LittleShort(pcx->ymin);
pcx->xmax = LittleShort(pcx->xmax);
pcx->ymax = LittleShort(pcx->ymax);
pcx->hres = LittleShort(pcx->hres);
pcx->vres = LittleShort(pcx->vres);
pcx->bytes_per_line = LittleShort(pcx->bytes_per_line);
pcx->palette_type = LittleShort(pcx->palette_type);
raw = &pcx->data;
if (pcx->manufacturer != 0x0a
|| pcx->version != 5
|| pcx->encoding != 1
|| pcx->bits_per_pixel != 8
|| pcx->xmax >= 640
|| pcx->ymax >= 480)
{
VID_Printf (PRINT_ALL, "Bad pcx file %s\n", filename);
return;
}
out = malloc ( (pcx->ymax+1) * (pcx->xmax+1) );
*pic = out;
pix = out;
if (palette)
{
*palette = malloc(768);
memcpy (*palette, (byte *)pcx + len - 768, 768);
}
if (width)
*width = pcx->xmax+1;
if (height)
*height = pcx->ymax+1;
for (y=0 ; y<=pcx->ymax ; y++, pix += pcx->xmax+1)
{
for (x=0 ; x<=pcx->xmax ; )
{
dataByte = *raw++;
if((dataByte & 0xC0) == 0xC0)
{
runLength = dataByte & 0x3F;
dataByte = *raw++;
}
else
runLength = 1;
while(runLength-- > 0)
pix[x++] = dataByte;
}
}
if ( raw - (byte *)pcx > len)
{
VID_Printf (PRINT_DEVELOPER, "PCX file %s was malformed", filename);
free (*pic);
*pic = NULL;
}
FS_FreeFile (pcx);
}
/*
=========================================================
TARGA LOADING
=========================================================
*/
// Definitions for image types
#define TGA_Null 0 // no image data
#define TGA_Map 1 // Uncompressed, color-mapped images
#define TGA_RGB 2 // Uncompressed, RGB images
#define TGA_Mono 3 // Uncompressed, black and white images
#define TGA_RLEMap 9 // Runlength encoded color-mapped images
#define TGA_RLERGB 10 // Runlength encoded RGB images
#define TGA_RLEMono 11 // Compressed, black and white images
#define TGA_CompMap 32 // Compressed color-mapped data, using Huffman, Delta, and runlength encoding
#define TGA_CompMap4 33 // Compressed color-mapped data, using Huffman, Delta, and runlength encoding. 4-pass quadtree-type process
// Definitions for interleave flag
#define TGA_IL_None 0 // non-interleaved
#define TGA_IL_Two 1 // two-way (even/odd) interleaving
#define TGA_IL_Four 2 // four way interleaving
#define TGA_IL_Reserved 3 // reserved
// Definitions for origin flag
#define TGA_O_UPPER 0 // Origin in lower left-hand corner
#define TGA_O_LOWER 1 // Origin in upper left-hand corner
#define MAXCOLORS 16384
typedef struct _TargaHeader {
unsigned char id_length, colormap_type, image_type;
unsigned short colormap_index, colormap_length;
unsigned char colormap_size;
unsigned short x_origin, y_origin, width, height;
unsigned char pixel_size, attributes;
} TargaHeader;
#if 1
/*
=============
R_LoadTGA
NiceAss: LoadTGA() from Q2Ice, it supports more formats
=============
*/
void R_LoadTGA( char *filename, byte **pic, int *width, int *height )
{
int w, h, x, y, i, temp1, temp2;
int realrow, truerow, baserow, size, interleave, origin;
int pixel_size, map_idx, mapped, rlencoded, RLE_count, RLE_flag;
TargaHeader header;
byte tmp[2], r, g, b, a, j, k, l;
byte *dst, *ColorMap, *data, *pdata;
// load file
FS_LoadFile( filename, &data );
if ( !data )
return;
pdata = data;
header.id_length = *pdata++;
header.colormap_type = *pdata++;
header.image_type = *pdata++;
tmp[0] = pdata[0];
tmp[1] = pdata[1];
header.colormap_index = LittleShort( *((short *)tmp) );
pdata+=2;
tmp[0] = pdata[0];
tmp[1] = pdata[1];
header.colormap_length = LittleShort( *((short *)tmp) );
pdata+=2;
header.colormap_size = *pdata++;
header.x_origin = LittleShort( *((short *)pdata) );
pdata+=2;
header.y_origin = LittleShort( *((short *)pdata) );
pdata+=2;
header.width = LittleShort( *((short *)pdata) );
pdata+=2;
header.height = LittleShort( *((short *)pdata) );
pdata+=2;
header.pixel_size = *pdata++;
header.attributes = *pdata++;
if( header.id_length )
pdata += header.id_length;
// validate TGA type
switch( header.image_type ) {
case TGA_Map:
case TGA_RGB:
case TGA_Mono:
case TGA_RLEMap:
case TGA_RLERGB:
case TGA_RLEMono:
break;
default:
VID_Error ( ERR_DROP, "R_LoadTGA: Only type 1 (map), 2 (RGB), 3 (mono), 9 (RLEmap), 10 (RLERGB), 11 (RLEmono) TGA images supported\n" );
return;
}
// validate color depth
switch( header.pixel_size ) {
case 8:
case 15:
case 16:
case 24:
case 32:
break;
default:
VID_Error ( ERR_DROP, "R_LoadTGA: Only 8, 15, 16, 24 and 32 bit images (with colormaps) supported\n" );
return;
}
r = g = b = a = l = 0;
// if required, read the color map information
ColorMap = NULL;
mapped = ( header.image_type == TGA_Map || header.image_type == TGA_RLEMap || header.image_type == TGA_CompMap || header.image_type == TGA_CompMap4 ) && header.colormap_type == 1;
if( mapped ) {
// validate colormap size
switch( header.colormap_size ) {
case 8:
case 16:
case 32:
case 24:
break;
default:
VID_Error ( ERR_DROP, "R_LoadTGA: Only 8, 16, 24 and 32 bit colormaps supported\n" );
return;
}
temp1 = header.colormap_index;
temp2 = header.colormap_length;
if( (temp1 + temp2 + 1) >= MAXCOLORS ) {
FS_FreeFile( data );
return;
}
ColorMap = (byte *)malloc( MAXCOLORS * 4 );
map_idx = 0;
for( i = temp1; i < temp1 + temp2; ++i, map_idx += 4 ) {
// read appropriate number of bytes, break into rgb & put in map
switch( header.colormap_size ) {
case 8:
r = g = b = *pdata++;
a = 255;
break;
case 15:
j = *pdata++;
k = *pdata++;
l = ((unsigned int) k << 8) + j;
r = (byte) ( ((k & 0x7C) >> 2) << 3 );
g = (byte) ( (((k & 0x03) << 3) + ((j & 0xE0) >> 5)) << 3 );
b = (byte) ( (j & 0x1F) << 3 );
a = 255;
break;
case 16:
j = *pdata++;
k = *pdata++;
l = ((unsigned int) k << 8) + j;
r = (byte) ( ((k & 0x7C) >> 2) << 3 );
g = (byte) ( (((k & 0x03) << 3) + ((j & 0xE0) >> 5)) << 3 );
b = (byte) ( (j & 0x1F) << 3 );
a = (k & 0x80) ? 255 : 0;
break;
case 24:
b = *pdata++;
g = *pdata++;
r = *pdata++;
a = 255;
l = 0;
break;
case 32:
b = *pdata++;
g = *pdata++;
r = *pdata++;
a = *pdata++;
l = 0;
break;
}
ColorMap[map_idx + 0] = r;
ColorMap[map_idx + 1] = g;
ColorMap[map_idx + 2] = b;
ColorMap[map_idx + 3] = a;
}
}
// check run-length encoding
rlencoded = header.image_type == TGA_RLEMap || header.image_type == TGA_RLERGB || header.image_type == TGA_RLEMono;
RLE_count = 0;
RLE_flag = 0;
w = header.width;
h = header.height;
if( width )
*width = w;
if( height )
*height = h;
size = w * h * 4;
*pic = (byte *)malloc( size );
memset( *pic, 0, size );
// read the Targa file body and convert to portable format
pixel_size = header.pixel_size;
origin = (header.attributes & 0x20) >> 5;
interleave = (header.attributes & 0xC0) >> 6;
truerow = 0;
baserow = 0;
for( y = 0; y < h; y++ ) {
realrow = truerow;
if( origin == TGA_O_UPPER )
realrow = h - realrow - 1;
dst = *pic + realrow * w * 4;
for( x = 0; x < w; x++ ) {
// check if run length encoded
if( rlencoded ) {
if( !RLE_count ) {
// have to restart run
i = *pdata++;
RLE_flag = (i & 0x80);
if( !RLE_flag ) {
// stream of unencoded pixels
RLE_count = i + 1;
} else {
// single pixel replicated
RLE_count = i - 127;
}
// decrement count & get pixel
--RLE_count;
} else {
// have already read count & (at least) first pixel
--RLE_count;
if( RLE_flag )
// replicated pixels
goto PixEncode;
}
}
// read appropriate number of bytes, break into RGB
switch( pixel_size ) {
case 8:
r = g = b = l = *pdata++;
a = 255;
break;
case 15:
j = *pdata++;
k = *pdata++;
l = ((unsigned int) k << 8) + j;
r = (byte) ( ((k & 0x7C) >> 2) << 3 );
g = (byte) ( (((k & 0x03) << 3) + ((j & 0xE0) >> 5)) << 3 );
b = (byte) ( (j & 0x1F) << 3 );
a = 255;
break;
case 16:
j = *pdata++;
k = *pdata++;
l = ((unsigned int) k << 8) + j;
r = (byte) ( ((k & 0x7C) >> 2) << 3 );
g = (byte) ( (((k & 0x03) << 3) + ((j & 0xE0) >> 5)) << 3 );
b = (byte) ( (j & 0x1F) << 3 );
a = 255;
break;
case 24:
b = *pdata++;
g = *pdata++;
r = *pdata++;
a = 255;
l = 0;
break;
case 32:
b = *pdata++;
g = *pdata++;
r = *pdata++;
a = *pdata++;
l = 0;
break;
default:
VID_Error( ERR_DROP, "Illegal pixel_size '%d' in file '%s'\n", filename );
return;
}
PixEncode:
if ( mapped )
{
map_idx = l * 4;
*dst++ = ColorMap[map_idx + 0];
*dst++ = ColorMap[map_idx + 1];
*dst++ = ColorMap[map_idx + 2];
*dst++ = ColorMap[map_idx + 3];
}
else
{
*dst++ = r;
*dst++ = g;
*dst++ = b;
*dst++ = a;
}
}
if (interleave == TGA_IL_Four)
truerow += 4;
else if (interleave == TGA_IL_Two)
truerow += 2;
else
truerow++;
if (truerow >= h)
truerow = ++baserow;
}
if (mapped)
free( ColorMap );
FS_FreeFile( data );
}
#else
/*
=============
R_LoadTGA
=============
*/
void R_LoadTGA (char *name, byte **pic, int *width, int *height)
{
int columns, rows, numPixels;
byte *pixbuf;
int row, column;
byte *buf_p;
byte *buffer;
int length;
TargaHeader targa_header;
byte *targa_rgba;
byte tmp[2];
*pic = NULL;
//
// load the file
//
length = FS_LoadFile (name, (void **)&buffer);
if (!buffer)
{ // Knightmare- removed this because it spams the console
//VID_Printf (PRINT_DEVELOPER, "Bad tga file %s\n", name);
return;
}
buf_p = buffer;
targa_header.id_length = *buf_p++;
targa_header.colormap_type = *buf_p++;
targa_header.image_type = *buf_p++;
tmp[0] = buf_p[0];
tmp[1] = buf_p[1];
targa_header.colormap_index = LittleShort ( *((short *)tmp) );
buf_p+=2;
tmp[0] = buf_p[0];
tmp[1] = buf_p[1];
targa_header.colormap_length = LittleShort ( *((short *)tmp) );
buf_p+=2;
targa_header.colormap_size = *buf_p++;
targa_header.x_origin = LittleShort ( *((short *)buf_p) );
buf_p+=2;
targa_header.y_origin = LittleShort ( *((short *)buf_p) );
buf_p+=2;
targa_header.width = LittleShort ( *((short *)buf_p) );
buf_p+=2;
targa_header.height = LittleShort ( *((short *)buf_p) );
buf_p+=2;
targa_header.pixel_size = *buf_p++;
targa_header.attributes = *buf_p++;
// Knightmare- check for bad data
if (!targa_header.width || !targa_header.height) {
VID_Printf (PRINT_ALL, "Bad tga file %s\n", name);
FS_FreeFile (buffer);
return;
}
if (targa_header.image_type != 2
&& targa_header.image_type != 10) {
// VID_Error (ERR_DROP, "R_LoadTGA: Only type 2 and 10 targa RGB images supported\n");
VID_Printf (PRINT_ALL, "R_LoadTGA: %s has wrong image format; only type 2 and 10 targa RGB images supported.\n", name);
FS_FreeFile (buffer);
return;
}
if (targa_header.colormap_type !=0
|| (targa_header.pixel_size!=32 && targa_header.pixel_size!=24)) {
// VID_Error (ERR_DROP, "R_LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n");
VID_Printf (PRINT_ALL, "R_LoadTGA: %s has wrong image format; only 32 or 24 bit images supported (no colormaps).\n", name);
FS_FreeFile (buffer);
return;
}
columns = targa_header.width;
rows = targa_header.height;
numPixels = columns * rows;
if (width)
*width = columns;
if (height)
*height = rows;
targa_rgba = malloc (numPixels*4);
*pic = targa_rgba;
if (targa_header.id_length != 0)
buf_p += targa_header.id_length; // skip TARGA image comment
if (targa_header.image_type==2) { // Uncompressed, RGB images
for(row=rows-1; row>=0; row--) {
pixbuf = targa_rgba + row*columns*4;
for(column=0; column<columns; column++) {
unsigned char red,green,blue,alphabyte;
switch (targa_header.pixel_size) {
case 24:
blue = *buf_p++;
green = *buf_p++;
red = *buf_p++;
*pixbuf++ = red;
*pixbuf++ = green;
*pixbuf++ = blue;
*pixbuf++ = 255;
break;
case 32:
blue = *buf_p++;
green = *buf_p++;
red = *buf_p++;
alphabyte = *buf_p++;
*pixbuf++ = red;
*pixbuf++ = green;
*pixbuf++ = blue;
*pixbuf++ = alphabyte;
break;
}
}
}
}
else if (targa_header.image_type==10) { // Runlength encoded RGB images
unsigned char red,green,blue,alphabyte,packetHeader,packetSize,j;
for(row=rows-1; row>=0; row--) {
pixbuf = targa_rgba + row*columns*4;
for(column=0; column<columns; ) {
packetHeader= *buf_p++;
packetSize = 1 + (packetHeader & 0x7f);
if (packetHeader & 0x80) { // run-length packet
switch (targa_header.pixel_size) {
case 24:
blue = *buf_p++;
green = *buf_p++;
red = *buf_p++;
alphabyte = 255;
break;
case 32:
blue = *buf_p++;
green = *buf_p++;
red = *buf_p++;
alphabyte = *buf_p++;
break;
}
for(j=0;j<packetSize;j++) {
*pixbuf++=red;
*pixbuf++=green;
*pixbuf++=blue;
*pixbuf++=alphabyte;
column++;
if (column==columns) { // run spans across rows
column=0;
if (row>0)
row--;
else
goto breakOut;
pixbuf = targa_rgba + row*columns*4;
}
}
}
else { // non run-length packet
for(j=0;j<packetSize;j++) {
switch (targa_header.pixel_size) {
case 24:
blue = *buf_p++;
green = *buf_p++;
red = *buf_p++;
*pixbuf++ = red;
*pixbuf++ = green;
*pixbuf++ = blue;
*pixbuf++ = 255;
break;
case 32:
blue = *buf_p++;
green = *buf_p++;
red = *buf_p++;
alphabyte = *buf_p++;
*pixbuf++ = red;
*pixbuf++ = green;
*pixbuf++ = blue;
*pixbuf++ = alphabyte;
break;
}
column++;
if (column==columns) { // pixel packet run spans across rows
column=0;
if (row>0)
row--;
else
goto breakOut;
pixbuf = targa_rgba + row*columns*4;
}
}
}
}
breakOut:;
}
}
FS_FreeFile (buffer);
}
#endif
/*
=================================================================
PNG LOADING
From Quake2Max
=================================================================
*/
#ifdef PNG_SUPPORT
// Knightmare- abstracted function call for png_set_gray_1_2_4_to_8()
#if defined (PNG_LIBPNG_VER) && (PNG_LIBPNG_VER < 10209)
#define PNG_GRAYFUNC_1_2_4_to_8(a) png_set_gray_1_2_4_to_8(a)
#else
#define PNG_GRAYFUNC_1_2_4_to_8(a) png_set_expand_gray_1_2_4_to_8(a)
#endif
typedef struct png_handle_s
{
char *tmpBuf;
int tmpi;
int /*long*/ fBgColor; // DL Background color Added 30/05/2000
int fTransparent; // DL Is this Image Transparent? Added 30/05/2000
int /*long*/ fRowBytes; // DL Added 30/05/2000
double fGamma; // DL Added 07/06/2000
double fScreenGamma; // DL Added 07/06/2000
char *fRowPtrs; // DL Changed for consistancy 30/05/2000
char *data; // property data: pByte read fData;
char *title;
char *author;
char *description;
int bitDepth;
int bytesPerPixel;
int colorType;
int height;
int width;
int interlace;
int compression;
int filter;
double lastModified;
int transparent;
} png_handle_t;
png_handle_t *r_png_handle = 0;
void R_InitializePNGData (void)
{
size_t /*long*/ *cvaluep; //ub
int /*long*/ y;
// Initialize Data and RowPtrs
if (r_png_handle->data)
{
free(r_png_handle->data);
r_png_handle->data = 0;
}
if (r_png_handle->fRowPtrs)
{
free(r_png_handle->fRowPtrs);
r_png_handle->fRowPtrs = 0;
}
r_png_handle->data = malloc(r_png_handle->height * r_png_handle->fRowBytes ); // DL Added 30/5/2000
r_png_handle->fRowPtrs = malloc(sizeof(void*) * r_png_handle->height);
if ((r_png_handle->data)&&(r_png_handle->fRowPtrs))
{
cvaluep = (size_t /*long*/*)r_png_handle->fRowPtrs;
for (y=0; y<r_png_handle->height; y++)
{
cvaluep[y] = (size_t /*long*/)r_png_handle->data + ( y * (size_t /*long*/)r_png_handle->fRowBytes ); //DL Added 08/07/2000
}
}
}
void R_CreatePNG (void)
{
if (r_png_handle)
return;
r_png_handle = malloc(sizeof(png_handle_t));
r_png_handle->data = 0;
r_png_handle->fRowPtrs = 0;
r_png_handle->height = 0;
r_png_handle->width = 0;
r_png_handle->colorType = PNG_COLOR_TYPE_RGBA; // was PNG_COLOR_TYPE_RGB
r_png_handle->interlace = PNG_INTERLACE_NONE;
r_png_handle->compression = PNG_COMPRESSION_TYPE_DEFAULT;
r_png_handle->filter = PNG_FILTER_TYPE_DEFAULT;
}
void R_DestroyPNG (qboolean keepData)
{
if (!r_png_handle)
return;
if (r_png_handle->data && !keepData)
free(r_png_handle->data);
if (r_png_handle->fRowPtrs)
free(r_png_handle->fRowPtrs);
free(r_png_handle);
r_png_handle = NULL;
}
void PNGAPI R_ReadPNGData (png_structp png, png_bytep data, png_size_t length)
{ // called by pnglib
int i;
for (i=0; i<length; i++)
data[i] = r_png_handle->tmpBuf[r_png_handle->tmpi++]; // give pnglib a some more bytes
}
/*
==============
R_LoadPNG
==============
*/
void R_LoadPNG (char *filename, byte **pic, int *width, int *height)
{
png_structp png;
png_infop pnginfo;
byte ioBuffer[8192];
int len;
byte *raw;
*pic = NULL;
len = FS_LoadFile (filename, (void **)&raw);
if (!raw)
{ // Knightmare- skip this unless developer >= 2 because it spams the console
if (developer->integer > 1)
VID_Printf (PRINT_DEVELOPER, "Bad png file %s\n", filename);
return;
}
if ( png_sig_cmp(raw,0,4) )
return;
png = png_create_read_struct (PNG_LIBPNG_VER_STRING,0,0,0);
if (!png)
return;
pnginfo = png_create_info_struct (png);
if (!pnginfo) {
png_destroy_read_struct (&png,&pnginfo,0);
return;
}
png_set_sig_bytes (png, 0/*sizeof( sig )*/);
R_CreatePNG (); // creates the r_png_handle struct
r_png_handle->tmpBuf = raw; //buf = whole file content
r_png_handle->tmpi=0;
png_set_read_fn (png, ioBuffer, R_ReadPNGData);
png_read_info (png, pnginfo);
png_get_IHDR (png, pnginfo, &r_png_handle->width, &r_png_handle->height, &r_png_handle->bitDepth,
&r_png_handle->colorType, &r_png_handle->interlace, &r_png_handle->compression, &r_png_handle->filter);
// ...removed bgColor code here...
if (r_png_handle->colorType == PNG_COLOR_TYPE_PALETTE)
png_set_palette_to_rgb(png);
if (r_png_handle->colorType == PNG_COLOR_TYPE_GRAY && r_png_handle->bitDepth < 8)
// png_set_gray_1_2_4_to_8 (png);
PNG_GRAYFUNC_1_2_4_to_8 (png);
// Add alpha channel if present
if ( png_get_valid(png, pnginfo, PNG_INFO_tRNS) )
png_set_tRNS_to_alpha (png);
// hax: expand 24bit to 32bit
// if (r_png_handle->bitDepth == 8 && r_png_handle->colorType == PNG_COLOR_TYPE_RGB)
// png_set_filler (png,255, PNG_FILLER_AFTER);
// Expand grayscale to RGB
if ( (r_png_handle->colorType == PNG_COLOR_TYPE_GRAY) || (r_png_handle->colorType == PNG_COLOR_TYPE_GRAY_ALPHA) )
png_set_gray_to_rgb (png);
if (r_png_handle->bitDepth < 8)
png_set_expand (png);
// hax: expand 24bit to 32bit
if (r_png_handle->bitDepth == 8 && r_png_handle->colorType == PNG_COLOR_TYPE_RGB)
png_set_filler (png,255, PNG_FILLER_AFTER);
// update the info structure
png_read_update_info( png, pnginfo );
r_png_handle->fRowBytes = (int)png_get_rowbytes (png, pnginfo);
r_png_handle->bytesPerPixel = png_get_channels (png, pnginfo); // DL Added 30/08/2000
R_InitializePNGData ();
if ((r_png_handle->data)&&(r_png_handle->fRowPtrs))
png_read_image (png, (png_bytepp)r_png_handle->fRowPtrs);
png_read_end (png, pnginfo); // read last information chunks
png_destroy_read_struct (&png, &pnginfo, 0);
// only load 32 bit by now...
if (r_png_handle->bitDepth == 8)
{
*pic= r_png_handle->data;
*width = r_png_handle->width;
*height = r_png_handle->height;
}
else
{
VID_Printf (PRINT_DEVELOPER, "Bad png color depth: %s\n", filename);
*pic = NULL;
free (r_png_handle->data);
}
R_DestroyPNG (true);
FS_FreeFile ((void *)raw);
}
#endif // PNG_SUPPORT
/*
=================================================================
JPEG LOADING
By Robert 'Heffo' Heffernan
=================================================================
*/
void jpg_null (j_decompress_ptr cinfo)
{
}
unsigned char jpg_fill_input_buffer (j_decompress_ptr cinfo)
{
VID_Printf(PRINT_ALL, "Premature end of JPEG data\n");
return 1;
}
void jpg_skip_input_data (j_decompress_ptr cinfo, long num_bytes)
{
cinfo->src->next_input_byte += (size_t) num_bytes;
cinfo->src->bytes_in_buffer -= (size_t) num_bytes;
if (cinfo->src->bytes_in_buffer < 0)
VID_Printf(PRINT_ALL, "Premature end of JPEG data\n");
}
//void jpeg_mem_src (j_decompress_ptr cinfo, const byte *mem, unsigned long len)
void jpeg_mem_src (j_decompress_ptr cinfo, const byte *mem, size_t len)
{
cinfo->src = (struct jpeg_source_mgr *)(*cinfo->mem->alloc_small)((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(struct jpeg_source_mgr));
cinfo->src->init_source = jpg_null;
cinfo->src->fill_input_buffer = jpg_fill_input_buffer;
cinfo->src->skip_input_data = jpg_skip_input_data;
cinfo->src->resync_to_restart = jpeg_resync_to_restart;
cinfo->src->term_source = jpg_null;
cinfo->src->bytes_in_buffer = len;
cinfo->src->next_input_byte = mem;
}
#define DSTATE_START 200 /* after create_decompress */
#define DSTATE_INHEADER 201 /* reading header markers, no SOS yet */
/*
==============
R_LoadJPG
==============
*/
void R_LoadJPG (char *filename, byte **pic, int *width, int *height)
{
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
byte *rawdata, *rgbadata, *scanline, *p, *q;
int rawsize, i;
// Load JPEG file into memory
rawsize = FS_LoadFile(filename, (void **)&rawdata);
if (!rawdata)
{
// Knightmare- skip this unless developer >= 2 because it spams the console
if (developer->integer > 1)
VID_Printf (PRINT_DEVELOPER, "Bad jpg file %s\n", filename);
return;
}
// Knightmare- check for bad data
if ( rawdata[6] != 'J'
|| rawdata[7] != 'F'
|| rawdata[8] != 'I'
|| rawdata[9] != 'F') {
VID_Printf (PRINT_ALL, "Bad jpg file %s\n", filename);
FS_FreeFile(rawdata);
return;
}
// Initialise libJpeg Object
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&cinfo);
// Feed JPEG memory into the libJpeg Object
jpeg_mem_src(&cinfo, rawdata, rawsize);
// Process JPEG header
jpeg_read_header(&cinfo, true); // bombs out here
// Start Decompression
jpeg_start_decompress(&cinfo);
// Check Color Components
if (cinfo.output_components != 3)
{
VID_Printf(PRINT_ALL, "Invalid JPEG color components in %s\n", filename);
jpeg_destroy_decompress(&cinfo);
FS_FreeFile(rawdata);
return;
}
// Allocate Memory for decompressed image
rgbadata = malloc(cinfo.output_width * cinfo.output_height * 4);
if (!rgbadata)
{
VID_Printf(PRINT_ALL, "Insufficient RAM for JPEG buffer\n");
jpeg_destroy_decompress(&cinfo);
FS_FreeFile(rawdata);
return;
}
// Pass sizes to output
*width = cinfo.output_width; *height = cinfo.output_height;
// Allocate Scanline buffer
scanline = malloc(cinfo.output_width * 3);
if (!scanline)
{
VID_Printf(PRINT_ALL, "Insufficient RAM for JPEG scanline buffer\n");
free(rgbadata);
jpeg_destroy_decompress(&cinfo);
FS_FreeFile(rawdata);
return;
}
// Read Scanlines, and expand from RGB to RGBA
q = rgbadata;
while (cinfo.output_scanline < cinfo.output_height)
{
p = scanline;
jpeg_read_scanlines(&cinfo, &scanline, 1);
for (i=0; i<cinfo.output_width; i++)
{
q[0] = p[0];
q[1] = p[1];
q[2] = p[2];
q[3] = 255;
p+=3; q+=4;
}
}
// Free the scanline buffer
free(scanline);
// Finish Decompression
jpeg_finish_decompress(&cinfo);
// Destroy JPEG object
jpeg_destroy_decompress(&cinfo);
// Free raw data buffer
FS_FreeFile(rawdata);
// Return the 'rgbadata'
*pic = rgbadata;
}
/*
====================================================================
IMAGE FLOOD FILLING
====================================================================
*/
/*
=================
Mod_FloodFillSkin
Fill background pixels so mipmapping doesn't have haloes
=================
*/
typedef struct
{
short x, y;
} floodfill_t;
// must be a power of 2
#define FLOODFILL_FIFO_SIZE 0x1000
#define FLOODFILL_FIFO_MASK (FLOODFILL_FIFO_SIZE - 1)
#define FLOODFILL_STEP( off, dx, dy ) \
{ \
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]; \
}
void R_FloodFillSkin( byte *skin, int skinwidth, int skinheight )
{
byte fillcolor = *skin; // assume this is the pixel to fill
floodfill_t fifo[FLOODFILL_FIFO_SIZE];
int inpt = 0, outpt = 0;
int filledcolor = -1;
int i;
if (filledcolor == -1)
{
filledcolor = 0;
// attempt to find opaque black
for (i = 0; i < 256; ++i)
if (d_8to24table[i] == (255 << 0)) // alpha 1.0
{
filledcolor = i;
break;
}
}
// can't fill to filled color or to transparent color (used as visited marker)
if ((fillcolor == filledcolor) || (fillcolor == 255))
{
//printf( "not filling skin from %d to %d\n", fillcolor, filledcolor );
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;
}
}
//=======================================================
/*
================
GL_ResampleTextureLerpLine
from DarkPlaces
================
*/
void GL_ResampleTextureLerpLine (byte *in, byte *out, int inwidth, int outwidth)
{
int j, xi, oldx = 0, f, fstep, l1, l2, endx;
fstep = (int) (inwidth*65536.0f/outwidth);
endx = (inwidth-1);
for (j = 0,f = 0;j < outwidth;j++, f += fstep)
{
xi = (int) f >> 16;
if (xi != oldx)
{
in += (xi - oldx) * 4;
oldx = xi;
}
if (xi < endx)
{
l2 = f & 0xFFFF;
l1 = 0x10000 - l2;
*out++ = (byte) ((in[0] * l1 + in[4] * l2) >> 16);
*out++ = (byte) ((in[1] * l1 + in[5] * l2) >> 16);
*out++ = (byte) ((in[2] * l1 + in[6] * l2) >> 16);
*out++ = (byte) ((in[3] * l1 + in[7] * l2) >> 16);
}
else // last pixel of the line has no pixel to lerp to
{
*out++ = in[0];
*out++ = in[1];
*out++ = in[2];
*out++ = in[3];
}
}
}
/*
================
GL_ResampleTexture
================
*/
void GL_ResampleTexture (void *indata, int inwidth, int inheight, void *outdata, int outwidth, int outheight)
{
int i, j, yi, oldy, f, fstep, l1, l2, endy = (inheight-1);
byte *inrow, *out, *row1, *row2;
out = outdata;
fstep = (int) (inheight*65536.0f/outheight);
row1 = malloc(outwidth*4);
row2 = malloc(outwidth*4);
inrow = indata;
oldy = 0;
GL_ResampleTextureLerpLine (inrow, row1, inwidth, outwidth);
GL_ResampleTextureLerpLine (inrow + inwidth*4, row2, inwidth, outwidth);
for (i = 0, f = 0;i < outheight;i++,f += fstep)
{
yi = f >> 16;
if (yi != oldy)
{
inrow = (byte *)indata + inwidth*4*yi;
if (yi == oldy+1)
memcpy(row1, row2, outwidth*4);
else
GL_ResampleTextureLerpLine (inrow, row1, inwidth, outwidth);
if (yi < endy)
GL_ResampleTextureLerpLine (inrow + inwidth*4, row2, inwidth, outwidth);
else
memcpy(row2, row1, outwidth*4);
oldy = yi;
}
if (yi < endy)
{
l2 = f & 0xFFFF;
l1 = 0x10000 - l2;
for (j = 0;j < outwidth;j++)
{
*out++ = (byte) ((*row1++ * l1 + *row2++ * l2) >> 16);
*out++ = (byte) ((*row1++ * l1 + *row2++ * l2) >> 16);
*out++ = (byte) ((*row1++ * l1 + *row2++ * l2) >> 16);
*out++ = (byte) ((*row1++ * l1 + *row2++ * l2) >> 16);
}
row1 -= outwidth*4;
row2 -= outwidth*4;
}
else // last line has no pixels to lerp to
{
for (j = 0;j < outwidth;j++)
{
*out++ = *row1++;
*out++ = *row1++;
*out++ = *row1++;
*out++ = *row1++;
}
row1 -= outwidth*4;
}
}
free(row1);
free(row2);
}
/*
void GL_ResampleTexture (unsigned *in, int inwidth, int inheight, unsigned *out, int outwidth, int outheight)
{
int i, j;
unsigned *inrow, *inrow2;
unsigned frac, fracstep;
unsigned p1[1024], p2[1024];
byte *pix1, *pix2, *pix3, *pix4;
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;
}
for (i=0 ; i<outheight ; i++, out += outwidth)
{
inrow = in + inwidth*(int)((i+0.25)*inheight/outheight);
inrow2 = in + inwidth*(int)((i+0.75)*inheight/outheight);
frac = fracstep >> 1;
for (j=0 ; j<outwidth ; j++)
{
pix1 = (byte *)inrow + p1[j];
pix2 = (byte *)inrow + p2[j];
pix3 = (byte *)inrow2 + p1[j];
pix4 = (byte *)inrow2 + p2[j];
((byte *)(out+j))[0] = (pix1[0] + pix2[0] + pix3[0] + pix4[0])>>2;
((byte *)(out+j))[1] = (pix1[1] + pix2[1] + pix3[1] + pix4[1])>>2;
((byte *)(out+j))[2] = (pix1[2] + pix2[2] + pix3[2] + pix4[2])>>2;
((byte *)(out+j))[3] = (pix1[3] + pix2[3] + pix3[3] + pix4[3])>>2;
}
}
}*/
#define MAX_UPSAMPLE_FACTOR 5 // limit to 5 (32x scaling)
/*
================
GL_UpscaleTexture
================
*/
void GL_UpscaleTexture (void *indata, int inwidth, int inheight, void *outdata, int scaleFactor, qboolean blend)
{
if ( !indata || !outdata || (scaleFactor < 1) || (scaleFactor > MAX_UPSAMPLE_FACTOR) )
return;
// if ( (r_font_upscale->integer >= 2) && (scaleFactor == 1) ) {
if ( blend && (scaleFactor == 1) ) {
R_Upscale2x_Render (outdata, indata, inwidth, inheight);
}
// else if ( (r_font_upscale->integer >= 2) && (scaleFactor == 2) ) {
else if ( blend && (scaleFactor == 2) ) {
R_Upscale4x_Render (outdata, indata, inwidth, inheight);
}
else // if (scaleFactor >= 3) // just block-copy each pixel
{
int sizeMult = (1 << scaleFactor);
int x, y, i, j;
unsigned *inL, *inP, *outL, *outP;
for (y = 0; y < inheight; y++)
{
inL = (unsigned *)indata + (y * inwidth);
outL = (unsigned *)outdata + (y * inwidth * sizeMult * sizeMult);
for (x = 0; x < inwidth; x++)
{
inP = inL + x;
outP = outL + (x * sizeMult);
// copy each input pixel to sizeMult^2 pixels
for (i = 0; i < sizeMult; i++)
{
for (j = 0; j < sizeMult; j++)
{
*(outP + (i * inwidth * sizeMult) + j) = *inP;
}
}
}
}
}
}
/*
================
GL_LightScaleTexture
Scale up the pixel values in a texture to increase the
lighting range
================
*/
void GL_LightScaleTexture (unsigned *in, int inwidth, int inheight, qboolean only_gamma )
{
if ( only_gamma )
{
int i, c;
byte *p;
p = (byte *)in;
c = inwidth*inheight;
for (i=0 ; i<c ; i++, p+=4)
{
p[0] = gammatable[p[0]];
p[1] = gammatable[p[1]];
p[2] = gammatable[p[2]];
}
}
else
{
int i, c;
byte *p;
p = (byte *)in;
c = inwidth*inheight;
for (i=0 ; i<c ; i++, p+=4)
{
p[0] = gammatable[intensitytable[p[0]]];
p[1] = gammatable[intensitytable[p[1]]];
p[2] = gammatable[intensitytable[p[2]]];
}
}
}
/*
================
GL_MipMap
Operates in place, quartering the size of the texture
================
*/
void GL_MipMap (byte *in, int width, int height)
{
int i, j;
byte *out;
width <<=2;
height >>= 1;
out = in;
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;
}
}
}
/*
================
GL_BuildPalettedTexture
================
*/
void GL_BuildPalettedTexture (unsigned char *paletted_texture, unsigned char *scaled, int scaled_width, int scaled_height)
{
int i;
for ( i = 0; i < scaled_width * scaled_height; i++ )
{
unsigned int r, g, b, c;
r = ( scaled[0] >> 3 ) & 31;
g = ( scaled[1] >> 2 ) & 63;
b = ( scaled[2] >> 3 ) & 31;
c = r | ( g << 5 ) | ( b << 11 );
paletted_texture[i] = glState.d_16to8table[c];
scaled += 4;
}
}
/*
===============
here starts modified code
by Heffo/changes by Nexus
===============
*/
static int upload_width, upload_height; //** DMP made local to module
static qboolean uploaded_paletted; //** DMP ditto
/*
static qboolean IsPowerOf2 (int value)
{
int i = 1;
while (1) {
if (value == i)
return true;
if (i > value)
return false;
i <<= 1;
}
}
*/
int NearestPowerOf2 (int size)
{
int i = 2;
// NeVo - infinite loop bug-fix
// if (size == 1)
if (size < 2) // FS: Better fix
return size;
while (1)
{
i <<= 1;
if (size == i)
return i;
if (size > i && size < (i << 1))
{
if (size >= ((i + (i << 1))/2))
return i << 1;
else
return i;
}
};
}
/*
===============
GL_Upload32
Returns has_alpha
===============
*/
qboolean GL_Upload32 (unsigned *data, int width, int height, imagetype_t type)
{
unsigned *scaled = NULL;
int scaled_width, scaled_height;
int i, c, comp, idealImgRes = 256, upscaleFactor = 0;
qboolean mipmap, hasAlpha, isNPOT, resampled = false;
byte *scan;
mipmap = ( (type != it_pic) && (type != it_font) && (type != it_scrap) && (type != it_sky) );
uploaded_paletted = false;
// get best upscale size for old fonts
if ( (type == it_font) && (width == 128) && (height == 128) && r_font_upscale->integer ) {
idealImgRes = NearestPowerOf2(min(vid.width, vid.height)) / 2;
idealImgRes = min(idealImgRes, glConfig.max_texsize);
idealImgRes = max(idealImgRes, 256);
// VID_Printf (PRINT_DEVELOPER, "GL_Upload32: ideal font res is %d.\n", idealImgRes);
}
// get best upscale size for scrap
if ( (type == it_scrap) && r_scrap_upscale->integer ) {
idealImgRes = NearestPowerOf2(min(vid.width, vid.height));
idealImgRes = min(idealImgRes, glConfig.max_texsize);
idealImgRes = max(idealImgRes, 256);
// VID_Printf (PRINT_DEVELOPER, "GL_Upload32: ideal scrap res is %d.\n", idealImgRes);
}
//
// scan the texture for any non-255 alpha
//
c = width*height;
scan = ((byte *)data) + 3;
hasAlpha = false;
for (i = 0; i < c; i++, scan += 4)
{
if ( *scan != 255 ) {
hasAlpha = true;
break;
}
}
// Heffo - ARB Texture Compression
qglHint(GL_TEXTURE_COMPRESSION_HINT_ARB, GL_NICEST);
comp = (glState.texture_compression && (type != it_pic) && (type != it_font) && (type != it_scrap)) ? GL_COMPRESSED_RGBA_ARB : GL_RGBA;
//
// find sizes to scale to
//
if ( glConfig.arbTextureNonPowerOfTwo && (!mipmap || r_nonpoweroftwo_mipmaps->integer) ) {
scaled_width = width;
scaled_height = height;
isNPOT = ( (NearestPowerOf2(width) != width) || (NearestPowerOf2(height) != height) );
}
else {
scaled_width = NearestPowerOf2 (width);
scaled_height = NearestPowerOf2 (height);
isNPOT = false;
}
if (scaled_width > glConfig.max_texsize)
scaled_width = glConfig.max_texsize;
if (scaled_height > glConfig.max_texsize)
scaled_height = glConfig.max_texsize;
//
// allow sampling down of the world textures for speed
//
if (mipmap && r_picmip->integer > 0)
{
int maxsize;
if (r_picmip->integer == 1) // clamp to 1024x1024
maxsize = 1024;
else if (r_picmip->integer == 2) // clamp to 512x512
maxsize = 512;
else if (r_picmip->integer == 3) // clamp to 256x256
maxsize = 256;
else // clamp to 128x128
maxsize = 128;
while (1) {
if (scaled_width <= maxsize && scaled_height <= maxsize)
break;
scaled_width >>= 1;
scaled_height >>= 1;
}
// scaled_width >>= r_picmip->integer;
// scaled_height >>= r_picmip->integer;
}
//
// resample texture if needed
//
if ( ( (type == it_font) && r_font_upscale->integer ) || ( (type == it_scrap) && r_scrap_upscale->integer )
&& (scaled_width == scaled_height) && ((scaled_width * 2) <= idealImgRes) ) // scale up fonts
{
while (1) {
if ( ((scaled_width * 2) > idealImgRes) && ((scaled_height * 2) > idealImgRes) )
break;
if (upscaleFactor >= MAX_UPSAMPLE_FACTOR) // don't go past 32x scaling
break;
scaled_width <<= 1;
scaled_height <<= 1;
upscaleFactor++;
}
if (upscaleFactor > 0)
{
upscaleFactor = min(upscaleFactor, MAX_UPSAMPLE_FACTOR); // clamp to max upscale factor
VID_Printf (PRINT_DEVELOPER, "GL_Upload32: scaling font image from %dx%d to %dx%d.\n", width, height, scaled_width, scaled_height);
scaled = malloc((scaled_width * scaled_height) * 4);
if (type == it_font)
GL_UpscaleTexture (data, width, height, scaled, upscaleFactor, (r_font_upscale->integer >= 2));
else
GL_UpscaleTexture (data, width, height, scaled, upscaleFactor, (r_scrap_upscale->integer >= 2));
resampled = true;
}
else {
scaled_width = width;
scaled_height = height;
scaled = data;
resampled = false;
}
}
else if (scaled_width != width || scaled_height != height) {
scaled = malloc((scaled_width * scaled_height) * 4);
GL_ResampleTexture (data, width, height, scaled, scaled_width, scaled_height);
resampled = true;
}
else {
scaled_width = width;
scaled_height = height;
scaled = data;
resampled = false;
}
if (!glState.gammaRamp)
GL_LightScaleTexture (scaled, scaled_width, scaled_height, !mipmap );
//
// generate mipmaps and upload
//
#ifdef USE_GLU_MIPMAP
if (mipmap)
{
if (glState.sgis_mipmap) {
qglTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, true);
qglTexImage2D (GL_TEXTURE_2D, 0, comp, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaled);
}
else
gluBuild2DMipmaps (GL_TEXTURE_2D, comp, scaled_width, scaled_height, GL_RGBA, GL_UNSIGNED_BYTE, scaled);
}
else
qglTexImage2D (GL_TEXTURE_2D, 0, comp, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaled);
#else // USE_GLU_MIPMAP
qglTexImage2D (GL_TEXTURE_2D, 0, comp, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaled);
if (mipmap)
{
int mip_width, mip_height, miplevel = 0;
mip_width = scaled_width; mip_height = scaled_height;
while (mip_width > 1 || mip_height > 1)
{
GL_MipMap ((byte *)scaled, mip_width, mip_height);
mip_width = max(mip_width>>1, 1);
mip_height = max(mip_height>>1, 1);
miplevel++;
qglTexImage2D (GL_TEXTURE_2D, miplevel, comp, mip_width, mip_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaled);
}
}
#endif // USE_GLU_MIPMAP
// if (scaled_width != width || scaled_height != height)
if (resampled)
free(scaled);
upload_width = scaled_width; upload_height = scaled_height;
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, (mipmap) ? gl_filter_min : gl_filter_max);
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
// Set anisotropic filter if supported and enabled
if (mipmap && glConfig.anisotropic && r_anisotropic->value)
qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, r_anisotropic->value);
return hasAlpha;
}
/*
===============
GL_Upload8
Returns has_alpha
===============
*/
qboolean GL_Upload8 (byte *data, int width, int height, imagetype_t type)
{
// unsigned trans[512*256];
unsigned *trans = NULL; // Knightmare- changed to dynamic allocation
int i, s;
int p;
qboolean has_alpha; // Knightmare added
s = width*height;
// if (s > sizeof(trans)/4)
// VID_Error (ERR_DROP, "GL_Upload8: too large");
trans = (unsigned *)malloc(s*4); // Knightmare- changed to dynamic allocation
for (i=0 ; i<s ; i++)
{
p = data[i];
trans[i] = d_8to24table[p];
if (p == 255)
{ // transparent, so scan around for another color
// to avoid alpha fringes
// FIXME: do a full flood fill so mips work...
if (i > width && data[i-width] != 255)
p = data[i-width];
else if (i < s-width && data[i+width] != 255)
p = data[i+width];
else if (i > 0 && data[i-1] != 255)
p = data[i-1];
else if (i < s-1 && data[i+1] != 255)
p = data[i+1];
else
p = 0;
// copy rgb components
((byte *)&trans[i])[0] = ((byte *)&d_8to24table[p])[0];
((byte *)&trans[i])[1] = ((byte *)&d_8to24table[p])[1];
((byte *)&trans[i])[2] = ((byte *)&d_8to24table[p])[2];
}
}
// return GL_Upload32 (trans, width, height, type);
// Knightmare- changed to dynamic allocation
has_alpha = GL_Upload32 (trans, width, height, type);
free (trans);
trans = NULL;
return has_alpha;
// end Knightmare
}
/*
================
R_LoadPic
This is also used as an entry point for the generated notexture
Nexus - changes for hires-textures
================
*/
image_t *R_LoadPic (char *name, byte *pic, int width, int height, imagetype_t type, int bits)
{
image_t *image;
int i;
// Nexus'added vars
int nameLen;
char refName[128];
// find a free image_t
for (i=0, image=gltextures ; i<numgltextures ; i++,image++)
{
if (!image->texnum)
break;
}
if (i == numgltextures)
{
if (numgltextures == MAX_GLTEXTURES)
VID_Error (ERR_DROP, "MAX_GLTEXTURES");
numgltextures++;
}
image = &gltextures[i];
if (strlen(name) >= sizeof(image->name))
VID_Error (ERR_DROP, "Draw_LoadPic: \"%s\" is too long", name);
// strncpy (image->name, name);
Q_strncpyz (image->name, sizeof(image->name), name);
image->hash = Com_HashFileName(name, 0, false); // Knightmare added
image->registration_sequence = registration_sequence;
image->width = width;
image->height = height;
image->type = type;
image->replace_scale_w = image->replace_scale_h = 1.0f; // Knightmare added
if (type == it_skin && bits == 8)
R_FloodFillSkin(pic, width, height);
// replacement scaling hack for TGA/JPEG HUD images and skins
// TODO: replace this with shaders as soon as they are supported
nameLen = (int)strlen(name);
// strncpy(s,name);
Q_strncpyz(refName, sizeof(refName), name);
// Load .pcx for size refereence, check if we have a tga/jpg/png pic
#ifdef PNG_SUPPORT
if ( (nameLen >= 5) && ((type == it_pic) || (type == it_font)) && (!strcmp(refName+nameLen-4, ".tga") || !strcmp(refName+nameLen-4, ".png") || !strcmp(refName+nameLen-4, ".jpg")) )
#else // PNG_SUPPORT
if ( (nameLen >= 5) && ((type == it_pic) || (type == it_font)) && (!strcmp(refName+nameLen-4, ".tga") || !strcmp(refName+nameLen-4, ".jpg")) )
#endif // PNG_SUPPORT
{
byte *pic, *palette;
int pcxwidth, pcxheight;
refName[nameLen-3]='p'; refName[nameLen-2]='c'; refName[nameLen-1]='x'; // replace extension
LoadPCX (refName, &pic, &palette, &pcxwidth, &pcxheight); // load .pcx file
if (pic && (pcxwidth > 0) && (pcxheight > 0)) {
image->replace_scale_w = (float)pcxwidth/image->width;
image->replace_scale_h = (float)pcxheight/image->height;
}
if (pic) free(pic);
if (palette) free(palette);
}
// load little pics into the scrap
if ( (image->type == it_pic) && (bits == 8)
&& (image->width < 64) && (image->height < 64) )
{
int x, y;
int i, j, k;
int texnum;
texnum = Scrap_AllocBlock (image->width, image->height, &x, &y);
if (texnum == -1)
goto nonscrap;
scrap_dirty = true;
// copy the texels into the scrap block
k = 0;
for (i=0 ; i<image->height ; i++)
for (j=0 ; j<image->width ; j++, k++)
scrap_texels[texnum][(y+i)*SCRAP_BLOCK_WIDTH + x + j] = pic[k];
image->texnum = TEXNUM_SCRAPS + texnum;
image->scrap = true;
image->has_alpha = true;
image->sl = (x+0.01)/(float)SCRAP_BLOCK_WIDTH;
image->sh = (x+image->width-0.01)/(float)SCRAP_BLOCK_WIDTH;
image->tl = (y+0.01)/(float)SCRAP_BLOCK_WIDTH;
image->th = (y+image->height-0.01)/(float)SCRAP_BLOCK_WIDTH;
}
else
{
nonscrap:
image->scrap = false;
image->texnum = TEXNUM_IMAGES + (image - gltextures);
GL_Bind(image->texnum);
if (bits == 8)
image->has_alpha = GL_Upload8 (pic, width, height, image->type);
else
image->has_alpha = GL_Upload32 ((unsigned *)pic, width, height, image->type);
image->upload_width = upload_width; // after power of 2 and scales
image->upload_height = upload_height;
image->paletted = uploaded_paletted;
image->sl = 0;
image->sh = 1;
image->tl = 0;
image->th = 1;
}
return image;
}
// store the names of last images that failed to load
#define NUM_FAIL_IMAGES 1024
char lastFailedImage[NUM_FAIL_IMAGES][MAX_OSPATH];
unsigned int lastFailedImageHash[NUM_FAIL_IMAGES];
static unsigned failedImgListIndex;
/*
===============
R_InitFailedImgList
===============
*/
void R_InitFailedImgList (void)
{
int i;
for (i=0; i<NUM_FAIL_IMAGES; i++) {
Com_sprintf(lastFailedImage[i], sizeof(lastFailedImage[i]), "\0");
lastFailedImageHash[i] = 0;
}
failedImgListIndex = 0;
}
/*
===============
R_CheckImgFailed
===============
*/
qboolean R_CheckImgFailed (char *name)
{
int i;
unsigned int hash;
hash = Com_HashFileName(name, 0, false);
for (i=0; i<NUM_FAIL_IMAGES; i++)
{
if (hash == lastFailedImageHash[i]) { // compare hash first
if (lastFailedImage[i] && strlen(lastFailedImage[i])
&& !strcmp(name, lastFailedImage[i]))
{ // we already tried to load this image, didn't find it
//VID_Printf (PRINT_ALL, "R_CheckImgFailed: found %s on failed to load list\n", name);
return true;
}
}
}
return false;
}
/*
===============
R_AddToFailedImgList
===============
*/
void R_AddToFailedImgList (char *name)
{
if (!strncmp(name, "save/", 5)) // don't add saveshots
return;
//VID_Printf (PRINT_ALL, "R_AddToFailedImgList: adding %s to failed to load list\n", name);
Com_sprintf(lastFailedImage[failedImgListIndex], sizeof(lastFailedImage[failedImgListIndex]), "%s", name);
lastFailedImageHash[failedImgListIndex] = Com_HashFileName(name, 0, false);
failedImgListIndex++;
// wrap around to start of list
if (failedImgListIndex >= NUM_FAIL_IMAGES)
failedImgListIndex = 0;
}
/*
================
R_LoadWal
================
*/
image_t *R_LoadWal (char *name, imagetype_t type)
{
miptex_t *mt;
int width, height, ofs;
image_t *image;
FS_LoadFile (name, (void **)&mt);
if (!mt)
{
if (type == it_wall)
VID_Printf (PRINT_ALL, "R_FindImage: can't load %s\n", name);
//return glMedia.notexture;
return NULL;
}
width = LittleLong (mt->width);
height = LittleLong (mt->height);
ofs = LittleLong (mt->offsets[0]);
image = R_LoadPic (name, (byte *)mt + ofs, width, height, it_wall, 8);
FS_FreeFile ((void *)mt);
return image;
}
/*
===============
R_FindImage
Finds or loads the given image
===============
*/
image_t *R_FindImage (char *name, imagetype_t type)
{
image_t *image;
int i, len;
byte *pic, *palette;
unsigned int hash;
int width, height;
char s[128];
char *tmp;
if (!name)
return NULL;
len = (int)strlen(name);
if (len<5)
return NULL;
// fix up bad image paths
tmp = name;
while ( *tmp != 0 )
{
if ( *tmp == '\\' )
*tmp = '/';
tmp++;
}
// look for it
hash = Com_HashFileName(name, 0, false);
for (i=0, image=gltextures; i<numgltextures; i++,image++)
{
if (hash == image->hash) { // compare hash first
if (!strcmp(name, image->name))
{
image->registration_sequence = registration_sequence;
return image;
}
}
}
// don't try again to load an image that just failed
if (R_CheckImgFailed (name))
{
if (!strcmp(name+len-4, ".tga"))
{
#ifdef PNG_SUPPORT
// fall back to png
Q_strncpyz (s, sizeof(s), name);
s[len-3]='p'; s[len-2]='n'; s[len-1]='g';
return R_FindImage(s,type);
#else // PNG_SUPPORT
// fall back to jpg
Q_strncpyz(s, sizeof(s), name);
s[len-3]='j'; s[len-2]='p'; s[len-1]='g';
return R_FindImage(s,type);
#endif // PNG_SUPPORT
}
#ifdef PNG_SUPPORT
else if (!strcmp(name+len-4, ".png"))
{ // fall back to jpg
Q_strncpyz (s, sizeof(s), name);
s[len-3]='j'; s[len-2]='p'; s[len-1]='g';
return R_FindImage(s,type);
}
#endif // PNG_SUPPORT
else
return NULL;
}
// MrG's automatic JPG & TGA loading
// search for TGAs or JPGs to replace .pcx and .wal images
if (!strcmp(name+len-4, ".pcx") || !strcmp(name+len-4, ".wal"))
{
// strncpy(s, name);
Q_strncpyz (s, sizeof(s), name);
s[len-3]='t'; s[len-2]='g'; s[len-1]='a';
image = R_FindImage(s,type);
if (image)
return image;
}
//
// load the pic from disk
//
pic = NULL;
palette = NULL;
if (!strcmp(name+len-4, ".pcx"))
{
LoadPCX (name, &pic, &palette, &width, &height);
if (pic)
image = R_LoadPic (name, pic, width, height, type, 8);
else
image = NULL;
}
else if (!strcmp(name+len-4, ".wal"))
{
image = R_LoadWal (name, type);
}
else if (!strcmp(name+len-4, ".tga"))
{
R_LoadTGA (name, &pic, &width, &height);
if (pic)
image = R_LoadPic (name, pic, width, height, type, 32);
#ifdef PNG_SUPPORT
else { // fall back to png
R_AddToFailedImgList(name);
Q_strncpyz (s, sizeof(s), name);
s[len-3]='p'; s[len-2]='n'; s[len-1]='g';
return R_FindImage(s,type);
}
#else // PNG_SUPPORT
else { // fall back to jpg
R_AddToFailedImgList(name);
Q_strncpyz(s, sizeof(s), name);
s[len-3]='j'; s[len-2]='p'; s[len-1]='g';
return R_FindImage(s,type);
}
#endif // PNG_SUPPORT
}
#ifdef PNG_SUPPORT
else if (!strcmp(name+len-4, ".png"))
{
R_LoadPNG (name, &pic, &width, &height);
if (pic)
image = R_LoadPic(name, pic, width, height, type, 32);
else { // fall back to jpg
R_AddToFailedImgList(name);
Q_strncpyz (s, sizeof(s), name);
s[len-3]='j'; s[len-2]='p'; s[len-1]='g';
return R_FindImage(s,type);
}
}
#endif // PNG_SUPPORT
else if (!strcmp(name+len-4, ".jpg")) // Heffo - JPEG support
{
R_LoadJPG(name, &pic, &width, &height);
if (pic)
image = R_LoadPic(name, pic, width, height, type, 32);
else
image = NULL;
}
/*else if (!strcmp(name+len-4, ".cin")) // Heffo
{ // WHY .cin files? because we can!
cinematics_t *newcin;
newcin = CIN_OpenCin(name);
if(!newcin)
return NULL;
pic = malloc(256*256*4);
memset(pic, 192, (256*256*4));
image = R_LoadPic (name, pic, 256, 256, type, 32);
newcin->texnum = image->texnum;
image->is_cin = true;
}*/
else
image = NULL;
if (!image)
R_AddToFailedImgList(name);
if (pic)
free(pic);
if (palette)
free(palette);
return image;
}
/*
===============
R_RegisterSkin
===============
*/
struct image_s *R_RegisterSkin (char *name)
{
return R_FindImage (name, it_skin);
}
/*
================
R_FreeUnusedImages
Any image that was not touched on this registration sequence
will be freed.
================
*/
void R_FreeUnusedImages (void)
{
int i;
image_t *image;
// never free notexture or particle textures
glMedia.notexture->registration_sequence = registration_sequence;
glMedia.whitetexture->registration_sequence = registration_sequence;
glMedia.distTextureARB->registration_sequence = registration_sequence;
#ifdef ROQ_SUPPORT
glMedia.rawtexture->registration_sequence = registration_sequence;
#endif // ROQ_SUPPORT
glMedia.envmappic->registration_sequence = registration_sequence;
glMedia.spheremappic->registration_sequence = registration_sequence;
glMedia.shelltexture->registration_sequence = registration_sequence;
glMedia.celshadetexture->registration_sequence = registration_sequence;
glMedia.causticwaterpic->registration_sequence = registration_sequence;
glMedia.causticslimepic->registration_sequence = registration_sequence;
glMedia.causticlavapic->registration_sequence = registration_sequence;
glMedia.particlebeam->registration_sequence = registration_sequence;
for (i=0; i<PARTICLE_TYPES; i++)
if (glMedia.particletextures[i]) // dont mess with null ones silly :p
glMedia.particletextures[i]->registration_sequence = registration_sequence;
for (i=0, image=gltextures; i<numgltextures; i++, image++)
{
if (image->registration_sequence == registration_sequence)
continue; // used this sequence
if (!image->registration_sequence)
continue; // free image_t slot
// if (image->type == it_pic)
if ( (image->type == it_pic) || (image->type == it_font) || (image->type == it_scrap) )
continue; // don't free pics or fonts
//Heffo - Free Cinematic
//if(image->is_cin)
// CIN_FreeCin(image->texnum);
// free it
qglDeleteTextures (1, &image->texnum);
memset (image, 0, sizeof(*image));
}
}
/*
===============
Draw_GetPalette
===============
*/
int Draw_GetPalette (void)
{
int i;
int r, g, b;
unsigned v;
byte *pic, *pal;
int width, height;
//int avg, dr, dg, db, d1, d2, d3; //** DMP
//float sat; //** DMP
// get the palette
LoadPCX ("pics/colormap.pcx", &pic, &pal, &width, &height);
if (!pal)
VID_Error (ERR_FATAL, "Couldn't load pics/colormap.pcx");
for (i=0 ; i<256 ; i++)
{
r = pal[i*3+0];
g = pal[i*3+1];
b = pal[i*3+2];
//** DMP adjust saturation
/*avg = (r + g + b + 2) / 3; // first calc grey value we'll desaturate to
dr = avg - r; // calc distance from grey value to each gun
dg = avg - g;
db = avg - b;
d1 = abs(r - g); // find greatest distance between all the guns
d2 = abs(g - b);
d3 = abs(b - r);
if (d1 > d2) // we will use this for our existing saturation
if (d1 > d3)
sat = d1;
else
if (d2 > d3)
sat = d2;
else
sat = d3;
else
if (d2 > d3)
sat = d2;
else
sat = d3;
sat /= 255.0; // convert existing saturationn to ratio
sat = 1.0 - sat; // invert so the most saturation causes the desaturation to lessen
sat *= (1.0 - r_saturation->value); // scale the desaturation value so our desaturation is non-linear (keeps lava looking good)
dr *= sat; // scale the differences by the amount we want to desaturate
dg *= sat;
db *= sat;
r += dr; // now move the gun values towards total grey by the amount we desaturated
g += dg;
b += db;*/
//** DMP end saturation mod
v = (255<<24) + (r<<0) + (g<<8) + (b<<16);
d_8to24table[i] = LittleLong(v);
}
d_8to24table[255] &= LittleLong(0xffffff); // 255 is transparent
free (pic);
free (pal);
return 0;
}
/*
===============
R_InitImages
===============
*/
void R_InitImages (void)
{
int i, j;
float g = vid_gamma->value;
// Knightmare- reinitialize these after a vid_restart
// this is needed because the renderer is no longer a DLL
gl_filter_min = GL_LINEAR_MIPMAP_NEAREST;
gl_filter_max = GL_LINEAR;
registration_sequence = 1;
// init intensity conversions
//r_intensity = Cvar_Get ("r_intensity", "2", CVAR_ARCHIVE);
// Knightmare- added Vic's RGB brightening
if (glConfig.mtexcombine)
r_intensity = Cvar_Get ("r_intensity", "1", 0);
else
r_intensity = Cvar_Get ("r_intensity", "2", 0);
Cvar_SetDescription ("r_intensity", "Sets intensity value for gamma table. Value range is >= 1.");
// end Knightmare
if ( r_intensity->value <= 1 )
Cvar_Set( "r_intensity", "1" );
glState.inverse_intensity = 1 / r_intensity->value;
R_InitFailedImgList (); // Knightmare added
Draw_GetPalette ();
/* if (qglColorTableEXT)
{
FS_LoadFile( "pics/16to8.dat", &glState.d_16to8table );
if ( !glState.d_16to8table )
VID_Error( ERR_FATAL, "Couldn't load pics/16to8.pcx");
} */
if (glConfig.rendType == GLREND_VOODOO)
//if ( glConfig.renderer & ( GL_RENDERER_VOODOO | GL_RENDERER_VOODOO2 ) )
{
g = 1.0F;
}
for ( i = 0; i < 256; i++ )
{
if ( g == 1 )
{
gammatable[i] = i;
}
else
{
float inf;
inf = 255 * pow ( (i+0.5)/255.5 , g ) + 0.5;
if (inf < 0)
inf = 0;
if (inf > 255)
inf = 255;
gammatable[i] = inf;
}
}
for (i=0 ; i<256 ; i++)
{
j = i*r_intensity->value;
if (j > 255)
j = 255;
intensitytable[i] = j;
}
R_Upscale_Init ();
R_InitBloomTextures (); // BLOOMS
}
/*
===============
R_FreePic
by Knightmare
Frees a single pic
===============
*/
void R_FreePic (char *name)
{
int i;
image_t *image;
for (i=0, image=gltextures; i<numgltextures; i++, image++)
{
if (!image->registration_sequence)
continue; // free image_t slot
if (image->type != it_pic)
continue; // only free pics
if (!strcmp(name, image->name))
{
//Heffo - Free Cinematic
//if (image->is_cin)
// CIN_FreeCin(image->texnum);
// free it
qglDeleteTextures (1, &image->texnum);
memset (image, 0, sizeof(*image));
return; //we're done here
}
}
}
/*
===============
R_ShutdownImages
===============
*/
void R_ShutdownImages (void)
{
int i;
image_t *image;
for (i=0, image=gltextures; i<numgltextures; i++, image++)
{
if (!image->registration_sequence)
continue; // free image_t slot
//Heffo - Free Cinematic
//if (image->is_cin)
// CIN_FreeCin(image->texnum);
// free it
qglDeleteTextures (1, &image->texnum);
memset (image, 0, sizeof(*image));
}
}
Reference in a new issue View git blame Copy permalink