/* =========================================================================== Copyright (C) 1999-2005 Id Software, Inc. This file is part of Quake III Arena source code. Quake III Arena 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 III Arena 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 Foobar; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA =========================================================================== */ // tr_image.c #include "tr_local.h" #include /* * Include file for users of JPEG library. * You will need to have included system headers that define at least * the typedefs FILE and size_t before you can include jpeglib.h. * (stdio.h is sufficient on ANSI-conforming systems.) * You may also wish to include "jerror.h". */ #define JPEG_INTERNALS #include static void LoadBMP( const char *name, byte **pic, int *width, int *height ); static void LoadTGA( const char *name, byte **pic, int *width, int *height ); static void LoadJPG( const char *name, byte **pic, int *width, int *height ); static byte s_intensitytable[256]; static unsigned char s_gammatable[256]; int gl_filter_min = GL_LINEAR_MIPMAP_NEAREST; int gl_filter_max = GL_LINEAR; #define FILE_HASH_SIZE 1024 static image_t* hashTable[FILE_HASH_SIZE]; extern qboolean scr_initialized; /* ** R_GammaCorrect */ void R_GammaCorrect( byte *buffer, int bufSize ) { int i; for ( i = 0; i < bufSize; i++ ) { buffer[i] = s_gammatable[buffer[i]]; } } typedef struct { char *name; int minimize, maximize; } textureMode_t; textureMode_t 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} }; /* ================ return a hash value for the filename ================ */ static long generateHashValue( const char *fname ) { int i; long hash; char letter; hash = 0; i = 0; while (fname[i] != '\0') { letter = tolower(fname[i]); if (letter =='.') break; // don't include extension if (letter =='\\') letter = '/'; // damn path names hash+=(long)(letter)*(i+119); i++; } hash &= (FILE_HASH_SIZE-1); return hash; } /* =============== GL_TextureMode =============== */ void GL_TextureMode( const char *string ) { int i; image_t *glt; for ( i=0 ; i< 6 ; i++ ) { if ( !Q_stricmp( modes[i].name, string ) ) { break; } } // hack to prevent trilinear from being set on voodoo, // because their driver freaks... if ( i == 5 && glConfig.hardwareType == GLHW_3DFX_2D3D ) { ri.Printf( PRINT_ALL, "Refusing to set trilinear on a voodoo.\n" ); i = 3; } if ( i == 6 ) { ri.Printf (PRINT_ALL, "bad filter name\n"); return; } gl_filter_min = modes[i].minimize; gl_filter_max = modes[i].maximize; // change all the existing mipmap texture objects for ( i = 0 ; i < tr.numImages ; i++ ) { glt = &tr.images[ i ]; if ( glt->numMipmaps && glt->texnum ) { GL_Bind (glt); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); } } } /* =============== R_SumOfUsedImages =============== */ int R_SumOfUsedImages( void ) { int total; int i; total = 0; for ( i = 0; i < tr.numImages; i++ ) { if ( tr.images[i].frameUsed == tr.frameCount ) { total += tr.images[i].uploadWidth * tr.images[i].uploadHeight; } } return total; } /* =============== R_ImageList_f =============== */ void R_ImageList_f( void ) { int i; image_t *image; int texels; const char *yesno[] = { "no ", "yes" }; ri.Printf (PRINT_ALL, "\n -w-- -h-- -mm- -TMU- -if-- wrap --name-------\n"); texels = 0; for ( i = 0 ; i < tr.numImages ; i++ ) { image = &tr.images[ i ]; texels += image->uploadWidth*image->uploadHeight; ri.Printf (PRINT_ALL, "%4i: %4i %4i %s %d ", i, image->uploadWidth, image->uploadHeight, yesno[image->numMipmaps], image->TMU ); switch ( image->internalFormat ) { case 1: ri.Printf( PRINT_ALL, "I " ); break; case 2: ri.Printf( PRINT_ALL, "IA " ); break; case 3: ri.Printf( PRINT_ALL, "RGB " ); break; case 4: ri.Printf( PRINT_ALL, "RGBA " ); break; case GL_RGBA8: ri.Printf( PRINT_ALL, "RGBA8" ); break; case GL_RGB8: ri.Printf( PRINT_ALL, "RGB8" ); break; case GL_RGB4_S3TC: ri.Printf( PRINT_ALL, "S3TC " ); break; case GL_RGBA4: ri.Printf( PRINT_ALL, "RGBA4" ); break; case GL_RGB5: ri.Printf( PRINT_ALL, "RGB5 " ); break; default: ri.Printf( PRINT_ALL, "???? " ); } switch ( image->wrapClampModeX ) { case GL_REPEAT: ri.Printf( PRINT_ALL, "rept " ); break; case GL_CLAMP: ri.Printf( PRINT_ALL, "clmp " ); break; default: ri.Printf( PRINT_ALL, "%4i ", image->wrapClampModeX ); break; } ri.Printf( PRINT_ALL, " %s\n", image->imgName ); } ri.Printf (PRINT_ALL, " ---------\n"); ri.Printf (PRINT_ALL, " %i total texels (not including mipmaps)\n", texels); ri.Printf (PRINT_ALL, " %i total images\n\n", tr.numImages ); } //======================================================================= /* ================ ResampleTexture Used to resample images in a more general than quartering fashion. This will only be filtered properly if the resampled size is greater than half the original size. If a larger shrinking is needed, use the mipmap function before or after. ================ */ static void ResampleTexture( unsigned *in, int inwidth, int inheight, unsigned *out, int outwidth, int outheight ) { int i, j; unsigned *inrow, *inrow2; unsigned frac, fracstep; unsigned p1[2048], p2[2048]; byte *pix1, *pix2, *pix3, *pix4; if (outwidth>2048) ri.Error(ERR_DROP, "ResampleTexture: max width"); fracstep = inwidth*0x10000/outwidth; frac = fracstep>>2; for ( i=0 ; i>16); frac += fracstep; } frac = 3*(fracstep>>2); for ( i=0 ; i>16); frac += fracstep; } for (i=0 ; i> 1; for (j=0 ; j>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; } } } /* ================ R_LightScaleTexture Scale up the pixel values in a texture to increase the lighting range ================ */ void R_LightScaleTexture (unsigned *in, int inwidth, int inheight, qboolean only_gamma ) { if (!tr.needsLightScale) { return; } if ( only_gamma ) { if ( !glConfig.deviceSupportsGamma ) { int i, c; byte *p; p = (byte *)in; c = inwidth*inheight; for (i=0 ; i>= 1; height >>= 1; if ( width == 0 || height == 0 ) { width += height; // get largest for (i=0 ; i>1; out[1] = ( in[1] + in[5] )>>1; out[2] = ( in[2] + in[6] )>>1; out[3] = ( in[3] + in[7] )>>1; } return; } for (i=0 ; i>2; out[1] = (in[1] + in[5] + in[row+1] + in[row+5])>>2; out[2] = (in[2] + in[6] + in[row+2] + in[row+6])>>2; out[3] = (in[3] + in[7] + in[row+3] + in[row+7])>>2; } } } /* ================== R_BlendOverTexture Apply a color blend over a set of pixels ================== */ static void R_BlendOverTexture( byte *data, int pixelCount, byte blend[4] ) { int i; int inverseAlpha; int premult[3]; inverseAlpha = 255 - blend[3]; premult[0] = blend[0] * blend[3]; premult[1] = blend[1] * blend[3]; premult[2] = blend[2] * blend[3]; for ( i = 0 ; i < pixelCount ; i++, data+=4 ) { data[0] = ( data[0] * inverseAlpha + premult[0] ) >> 9; data[1] = ( data[1] * inverseAlpha + premult[1] ) >> 9; data[2] = ( data[2] * inverseAlpha + premult[2] ) >> 9; } } byte mipBlendColors[16][4] = { {0,0,0,0}, {255,0,0,128}, {0,255,0,128}, {0,0,255,128}, {255,0,0,128}, {0,255,0,128}, {0,0,255,128}, {255,0,0,128}, {0,255,0,128}, {0,0,255,128}, {255,0,0,128}, {0,255,0,128}, {0,0,255,128}, {255,0,0,128}, {0,255,0,128}, {0,0,255,128}, }; /* =============== Upload32 =============== */ extern qboolean charSet; static void Upload32( unsigned int* data, int width, int height, int numMipmaps, qboolean picmip, qboolean dynamicallyUpdated, qboolean force32bit, qboolean hasAlpha, int* format, int* pUploadWidth, int* pUploadHeight, int* bytesUsed, qboolean bIsLightmap ) { int samples; unsigned *scaledBuffer = NULL; unsigned *resampledBuffer = NULL; int scaled_width, scaled_height; int i, c; byte *scan; GLenum internalFormat = GL_RGB; float rMax = 0, gMax = 0, bMax = 0; // // convert to exact power of 2 sizes // for (scaled_width = 1 ; scaled_width < width ; scaled_width<<=1) ; for (scaled_height = 1 ; scaled_height < height ; scaled_height<<=1) ; if ( r_roundImagesDown->integer && scaled_width > width ) scaled_width >>= 1; if ( r_roundImagesDown->integer && scaled_height > height ) scaled_height >>= 1; if ( scaled_width != width || scaled_height != height ) { resampledBuffer = ri.Hunk_AllocateTempMemory( scaled_width * scaled_height * 4 ); ResampleTexture (data, width, height, resampledBuffer, scaled_width, scaled_height); data = resampledBuffer; width = scaled_width; height = scaled_height; } // // perform optional picmip operation // if ( picmip ) { scaled_width >>= picmip; scaled_height >>= picmip; } // // clamp to minimum size // if (scaled_width < 1) { scaled_width = 1; } if (scaled_height < 1) { scaled_height = 1; } // // clamp to the current upper OpenGL limit // scale both axis down equally so we don't have to // deal with a half mip resampling // while ( scaled_width > glConfig.maxTextureSize || scaled_height > glConfig.maxTextureSize ) { scaled_width >>= 1; scaled_height >>= 1; } //scaledBuffer = ri.Hunk_AllocateTempMemory( 4 * scaled_width * scaled_height ); scaledBuffer = data; // // scan the texture for each channel's max values // and verify if the alpha channel is being used or not // c = width*height; scan = ((byte *)data); samples = 3; if (!bIsLightmap) { for ( i = 0; i < c; i++ ) { if ( scan[i*4+0] > rMax ) { rMax = scan[i*4+0]; } if ( scan[i*4+1] > gMax ) { gMax = scan[i*4+1]; } if ( scan[i*4+2] > bMax ) { bMax = scan[i*4+2]; } if ( scan[i*4 + 3] != 255 ) { samples = 4; break; } } // select proper internal format if ( samples == 3 ) { if (!force32bit) { if (r_texturebits->integer == 16) { internalFormat = GL_RGB5; } else if (r_texturebits->integer == 32) { internalFormat = GL_RGB8; } else if (r_colorbits->integer == 16) { internalFormat = GL_RGBA4; } else if (r_colorbits->integer == 32) { internalFormat = GL_RGBA8; } else { internalFormat = 3; } } else { internalFormat = GL_RGB8; } } else if ( samples == 4 ) { if (!force32bit) { if (r_texturebits->integer == 16) { internalFormat = GL_RGBA4; } else if (r_texturebits->integer == 32) { internalFormat = GL_RGBA8; } else if (r_colorbits->integer == 16) { internalFormat = GL_RGBA4; } else if (r_colorbits->integer == 32) { internalFormat = GL_RGBA8; } else { internalFormat = 4; } } else { internalFormat = GL_RGBA8; } } } else { internalFormat = GL_RGB; } // copy or resample data as appropriate for first MIP level if ( ( scaled_width == width ) && ( scaled_height == height ) ) { if (!numMipmaps) { qglTexImage2D (GL_TEXTURE_2D, 0, internalFormat, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); *pUploadWidth = scaled_width; *pUploadHeight = scaled_height; *format = internalFormat; *bytesUsed = samples * scaled_width * scaled_height; goto done; } //Com_Memcpy (scaledBuffer, data, width*height*4); } else { // use the normal mip-mapping function to go down from here while ( width > scaled_width || height > scaled_height ) { R_MipMap( (byte *)data, width, height ); width >>= 1; height >>= 1; if ( width < 1 ) { width = 1; } if ( height < 1 ) { height = 1; } } //Com_Memcpy( scaledBuffer, data, width * height * 4 ); } R_LightScaleTexture (scaledBuffer, scaled_width, scaled_height, !numMipmaps); *pUploadWidth = scaled_width; *pUploadHeight = scaled_height; *format = internalFormat; qglTexImage2D (GL_TEXTURE_2D, 0, internalFormat, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaledBuffer ); *bytesUsed = samples * scaled_width * scaled_height; if (numMipmaps) { int miplevel; miplevel = 0; while (scaled_width > 1 || scaled_height > 1) { R_MipMap( (byte *)scaledBuffer, scaled_width, scaled_height ); scaled_width >>= 1; scaled_height >>= 1; if (scaled_width < 1) scaled_width = 1; if (scaled_height < 1) scaled_height = 1; miplevel++; if ( r_colorMipLevels->integer ) { R_BlendOverTexture( (byte *)scaledBuffer, scaled_width * scaled_height, mipBlendColors[miplevel] ); } qglTexImage2D (GL_TEXTURE_2D, miplevel, internalFormat, scaled_width, scaled_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, scaledBuffer ); } } done: if (numMipmaps) { if ( textureFilterAnisotropic ) qglTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, (GLint)Com_Clamp( 1, maxAnisotropy, r_ext_max_anisotropy->integer ) ); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); } else { if (textureFilterAnisotropic) qglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); } GL_CheckErrors(); //if ( scaledBuffer != 0 ) // ri.Hunk_FreeTempMemory( scaledBuffer ); if ( resampledBuffer != 0 ) ri.Hunk_FreeTempMemory( resampledBuffer ); } static void UploadCompressed( byte* data, int width, int height, int numMipmaps, int iMipmapsAvailable, qboolean picmip, int glCompressMode, int* format, int* pUploadWidth, int* pUploadHeight, int* pBytesUsed ) { byte* offset; int i; int iStartImage; int size; int blockSize; int scaled_width, scaled_height; offset = data; iStartImage = 0; if (picmip > 0) { iStartImage = picmip; } if (iStartImage > 0 && iStartImage >= iMipmapsAvailable) { iStartImage = iMipmapsAvailable - 1; } scaled_width = width; scaled_height = height; if (iStartImage) { scaled_width = width >> iStartImage; scaled_height = height >> iStartImage; } while (scaled_width > glConfig.maxTextureSize || scaled_height > glConfig.maxTextureSize) { scaled_width >>= 1; scaled_height >>= 1; ++iStartImage; } if (iStartImage > 0 && iStartImage >= iMipmapsAvailable) { iStartImage = iMipmapsAvailable - 1; scaled_width = width >> (iMipmapsAvailable - 1); scaled_height = height >> (iMipmapsAvailable - 1); } *pUploadWidth = scaled_width; *pUploadHeight = scaled_height; *format = glCompressMode; blockSize = 16; if (glCompressMode == GL_COMPRESSED_RGB_S3TC_DXT1_EXT || glCompressMode == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT) { blockSize = 8; } scaled_width = width; scaled_height = height; for (i = 0; i < iStartImage; i++) { int w, h; w = (scaled_width + 3) / 4; if (w > 1) { h = (scaled_height + 3) / 4; if (h > 1) { offset += blockSize * w * h; } } scaled_width >>= 1; scaled_height >>= 1; if (!scaled_width) scaled_width = 1; if (!scaled_height) scaled_height = 1; } *pBytesUsed = 0; while (scaled_width || scaled_height) { int w, h; if (!scaled_width) scaled_width = 1; if (!scaled_height) scaled_height = 1; h = (scaled_height + 3) / 4; w = (scaled_width + 3) / 4; size = blockSize * w * h; if (w > 1 && h > 1) { *pBytesUsed += size; } qglCompressedTexImage2D(GL_TEXTURE_2D, i - iStartImage, glCompressMode, scaled_width, scaled_height, 0, size, offset); GL_CheckErrors(); if (i < iMipmapsAvailable && w > 1 && h > 1) { offset += size; } scaled_width >>= 1; scaled_height >>= 1; i++; } if (numMipmaps > 1) { qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_min); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max); } else { qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); } GL_CheckErrors(); } /* ================ R_CreateImage This is the only way any image_t are created ================ */ image_t* R_CreateImageOld( const char* name, byte* pic, int width, int height, int numMipmaps, int iMipmapsAvailable, qboolean allowPicmip, qboolean force32bit, qboolean hasAlpha, int glCompressMode, int glWrapClampModeX, int glWrapClampModeY ) { image_t *image; qboolean isLightmap = qfalse; qboolean dynamicallyUpdated = qfalse; int i; long hash; if (strlen(name) >= MAX_QPATH ) { ri.Error (ERR_DROP, "R_CreateImage: \"%s\" is too long\n", name); } if (!strncmp(name, "*lightmap", 9)) { isLightmap = qtrue; } else if (!strncmp(name, "*lightmapD", 10)) { dynamicallyUpdated = qtrue; } for (i = 0; i < tr.numImages; i++) { if (!tr.images[i].imgName[0]) { // found a free image break; } } if (i == tr.numImages) { if (tr.numImages == MAX_DRAWIMAGES) { ri.Error(ERR_DROP, "R_CreateImage: MAX_DRAWIMAGES hit\n"); } else { tr.numImages++; } } image = &tr.images[i]; //image->texnum = 1024 + i; // Fixed in OPM / ioquake3 // Original mohaa uses a fixed texnum instead of generating one regardless of the platform. // Here, by using glGenTextures, it will guarantee the uniqueness of the texture qglGenTextures(1, &image->texnum); image->numMipmaps = numMipmaps; image->allowPicmip = allowPicmip; image->dynamicallyUpdated = dynamicallyUpdated; image->force32bit = force32bit; Q_strncpyz (image->imgName, name, sizeof(image->imgName)); image->width = width; image->height = height; image->wrapClampModeX = glWrapClampModeX; image->wrapClampModeY = glWrapClampModeY; // lightmaps are always allocated on TMU 1 if ( qglActiveTextureARB && isLightmap ) { image->TMU = 1; } else { image->TMU = 0; } if ( qglActiveTextureARB ) { GL_SelectTexture( image->TMU ); } GL_Bind(image); if (glCompressMode) { UploadCompressed( (byte*)pic, image->width, image->height, image->numMipmaps, iMipmapsAvailable, allowPicmip, glCompressMode, &image->internalFormat, &image->uploadWidth, &image->uploadHeight, &image->bytesUsed ); } else { Upload32( (unsigned int*)pic, image->width, image->height, image->numMipmaps, allowPicmip, image->dynamicallyUpdated, force32bit, hasAlpha, &image->internalFormat, &image->uploadWidth, &image->uploadHeight, &image->bytesUsed, isLightmap ); } qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, glWrapClampModeX ); qglTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, glWrapClampModeY ); qglBindTexture( GL_TEXTURE_2D, 0 ); glState.currenttextures[image->TMU] = -1; if ( image->TMU == 1 ) { GL_SelectTexture( 0 ); } hash = generateHashValue(name); image->next = hashTable[hash]; hashTable[hash] = image; image->r_sequence = r_sequencenumber; return image; } /* ========================================================= BMP LOADING ========================================================= */ typedef struct { char id[2]; unsigned long fileSize; unsigned long reserved0; unsigned long bitmapDataOffset; unsigned long bitmapHeaderSize; unsigned long width; unsigned long height; unsigned short planes; unsigned short bitsPerPixel; unsigned long compression; unsigned long bitmapDataSize; unsigned long hRes; unsigned long vRes; unsigned long colors; unsigned long importantColors; unsigned char palette[256][4]; } BMPHeader_t; static void LoadBMP( const char *name, byte **pic, int *width, int *height ) { int columns, rows, numPixels; byte *pixbuf; int row, column; byte *buf_p; byte *buffer; int length; BMPHeader_t bmpHeader; byte *bmpRGBA; *pic = NULL; // // load the file // length = ri.FS_ReadFile( ( char * ) name, (void **)&buffer); if (!buffer) { return; } buf_p = buffer; bmpHeader.id[0] = *buf_p++; bmpHeader.id[1] = *buf_p++; bmpHeader.fileSize = LittleLong( * ( long * ) buf_p ); buf_p += 4; bmpHeader.reserved0 = LittleLong( * ( long * ) buf_p ); buf_p += 4; bmpHeader.bitmapDataOffset = LittleLong( * ( long * ) buf_p ); buf_p += 4; bmpHeader.bitmapHeaderSize = LittleLong( * ( long * ) buf_p ); buf_p += 4; bmpHeader.width = LittleLong( * ( long * ) buf_p ); buf_p += 4; bmpHeader.height = LittleLong( * ( long * ) buf_p ); buf_p += 4; bmpHeader.planes = LittleShort( * ( short * ) buf_p ); buf_p += 2; bmpHeader.bitsPerPixel = LittleShort( * ( short * ) buf_p ); buf_p += 2; bmpHeader.compression = LittleLong( * ( long * ) buf_p ); buf_p += 4; bmpHeader.bitmapDataSize = LittleLong( * ( long * ) buf_p ); buf_p += 4; bmpHeader.hRes = LittleLong( * ( long * ) buf_p ); buf_p += 4; bmpHeader.vRes = LittleLong( * ( long * ) buf_p ); buf_p += 4; bmpHeader.colors = LittleLong( * ( long * ) buf_p ); buf_p += 4; bmpHeader.importantColors = LittleLong( * ( long * ) buf_p ); buf_p += 4; Com_Memcpy( bmpHeader.palette, buf_p, sizeof( bmpHeader.palette ) ); if ( bmpHeader.bitsPerPixel == 8 ) buf_p += 1024; if ( bmpHeader.id[0] != 'B' && bmpHeader.id[1] != 'M' ) { ri.Error( ERR_DROP, "LoadBMP: only Windows-style BMP files supported (%s)\n", name ); } if ( bmpHeader.fileSize != length ) { ri.Error( ERR_DROP, "LoadBMP: header size does not match file size (%lu vs. %d) (%s)\n", bmpHeader.fileSize, length, name ); } if ( bmpHeader.compression != 0 ) { ri.Error( ERR_DROP, "LoadBMP: only uncompressed BMP files supported (%s)\n", name ); } if ( bmpHeader.bitsPerPixel < 8 ) { ri.Error( ERR_DROP, "LoadBMP: monochrome and 4-bit BMP files not supported (%s)\n", name ); } columns = bmpHeader.width; rows = bmpHeader.height; if ( rows < 0 ) rows = -rows; numPixels = columns * rows; if ( width ) *width = columns; if ( height ) *height = rows; bmpRGBA = ri.Malloc( numPixels * 4 ); *pic = bmpRGBA; for ( row = rows-1; row >= 0; row-- ) { pixbuf = bmpRGBA + row*columns*4; for ( column = 0; column < columns; column++ ) { unsigned char red, green, blue, alpha; int palIndex; unsigned short shortPixel; switch ( bmpHeader.bitsPerPixel ) { case 8: palIndex = *buf_p++; *pixbuf++ = bmpHeader.palette[palIndex][2]; *pixbuf++ = bmpHeader.palette[palIndex][1]; *pixbuf++ = bmpHeader.palette[palIndex][0]; *pixbuf++ = 0xff; break; case 16: shortPixel = * ( unsigned short * ) pixbuf; pixbuf += 2; *pixbuf++ = ( shortPixel & ( 31 << 10 ) ) >> 7; *pixbuf++ = ( shortPixel & ( 31 << 5 ) ) >> 2; *pixbuf++ = ( shortPixel & ( 31 ) ) << 3; *pixbuf++ = 0xff; break; 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++; alpha = *buf_p++; *pixbuf++ = red; *pixbuf++ = green; *pixbuf++ = blue; *pixbuf++ = alpha; break; default: ri.Error( ERR_DROP, "LoadBMP: illegal pixel_size '%d' in file '%s'\n", bmpHeader.bitsPerPixel, name ); break; } } } ri.FS_FreeFile( buffer ); } /* ================================================================= PCX LOADING ================================================================= */ /* ============== LoadPCX ============== */ static void LoadPCX ( const 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; int xmax, ymax; *pic = NULL; *palette = NULL; // // load the file // len = ri.FS_ReadFile( ( char * ) filename, (void **)&raw); if (!raw) { return; } // // parse the PCX file // pcx = (pcx_t *)raw; raw = (byte*)pcx->data; xmax = LittleShort(pcx->xmax); ymax = LittleShort(pcx->ymax); if (pcx->manufacturer != 0x0a || pcx->version != 5 || pcx->encoding != 1 || pcx->bits_per_pixel != 8 || xmax >= 1024 || ymax >= 1024) { ri.Printf (PRINT_ALL, "Bad pcx file %s (%i x %i) (%i x %i)\n", filename, xmax+1, ymax+1, pcx->xmax, pcx->ymax); return; } out = ri.Malloc ( (ymax+1) * (xmax+1) ); *pic = out; pix = out; if (palette) { *palette = ri.Malloc(768); Com_Memcpy (*palette, (byte *)pcx + len - 768, 768); } if (width) *width = xmax+1; if (height) *height = ymax+1; // FIXME: use bytes_per_line here? for (y=0 ; y<=ymax ; y++, pix += xmax+1) { for (x=0 ; x<=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) { ri.Printf (PRINT_DEVELOPER, "PCX file %s was malformed", filename); ri.Free (*pic); *pic = NULL; } ri.FS_FreeFile (pcx); } /* ============== LoadPCX32 ============== */ static void LoadPCX32 ( const char *filename, byte **pic, int *width, int *height) { byte *palette; byte *pic8; int i, c, p; byte *pic32; LoadPCX (filename, &pic8, &palette, width, height); if (!pic8) { *pic = NULL; return; } c = (*width) * (*height); pic32 = *pic = ri.Malloc(4 * c ); for (i = 0 ; i < c ; i++) { p = pic8[i]; pic32[0] = palette[p*3]; pic32[1] = palette[p*3 + 1]; pic32[2] = palette[p*3 + 2]; pic32[3] = 255; pic32 += 4; } ri.Free (pic8); ri.Free (palette); } //========================== // // DDS Loading // //========================== typedef unsigned int ui32_t; typedef struct ddsHeader_s { ui32_t headerSize; ui32_t flags; ui32_t height; ui32_t width; ui32_t pitchOrFirstMipSize; ui32_t volumeDepth; ui32_t numMips; ui32_t reserved1[11]; ui32_t always_0x00000020; ui32_t pixelFormatFlags; ui32_t fourCC; ui32_t rgbBitCount; ui32_t rBitMask; ui32_t gBitMask; ui32_t bBitMask; ui32_t aBitMask; ui32_t caps; ui32_t caps2; ui32_t caps3; ui32_t caps4; ui32_t reserved2; } ddsHeader_t; // flags: #define _DDSFLAGS_REQUIRED 0x001007 #define _DDSFLAGS_PITCH 0x8 #define _DDSFLAGS_MIPMAPCOUNT 0x20000 #define _DDSFLAGS_FIRSTMIPSIZE 0x80000 #define _DDSFLAGS_VOLUMEDEPTH 0x800000 // pixelFormatFlags: #define DDSPF_ALPHAPIXELS 0x1 #define DDSPF_ALPHA 0x2 #define DDSPF_FOURCC 0x4 #define DDSPF_RGB 0x40 #define DDSPF_YUV 0x200 #define DDSPF_LUMINANCE 0x20000 // caps: #define DDSCAPS_COMPLEX 0x8 #define DDSCAPS_MIPMAP 0x400000 #define DDSCAPS_REQUIRED 0x1000 // caps2: #define DDSCAPS2_CUBEMAP 0xFE00 #define DDSCAPS2_VOLUME 0x200000 typedef struct ddsHeaderDxt10_s { ui32_t dxgiFormat; ui32_t dimensions; ui32_t miscFlags; ui32_t arraySize; ui32_t miscFlags2; } ddsHeaderDxt10_t; // dxgiFormat // from http://msdn.microsoft.com/en-us/library/windows/desktop/bb173059%28v=vs.85%29.aspx typedef enum DXGI_FORMAT { DXGI_FORMAT_UNKNOWN = 0, DXGI_FORMAT_R32G32B32A32_TYPELESS = 1, DXGI_FORMAT_R32G32B32A32_FLOAT = 2, DXGI_FORMAT_R32G32B32A32_UINT = 3, DXGI_FORMAT_R32G32B32A32_SINT = 4, DXGI_FORMAT_R32G32B32_TYPELESS = 5, DXGI_FORMAT_R32G32B32_FLOAT = 6, DXGI_FORMAT_R32G32B32_UINT = 7, DXGI_FORMAT_R32G32B32_SINT = 8, DXGI_FORMAT_R16G16B16A16_TYPELESS = 9, DXGI_FORMAT_R16G16B16A16_FLOAT = 10, DXGI_FORMAT_R16G16B16A16_UNORM = 11, DXGI_FORMAT_R16G16B16A16_UINT = 12, DXGI_FORMAT_R16G16B16A16_SNORM = 13, DXGI_FORMAT_R16G16B16A16_SINT = 14, DXGI_FORMAT_R32G32_TYPELESS = 15, DXGI_FORMAT_R32G32_FLOAT = 16, DXGI_FORMAT_R32G32_UINT = 17, DXGI_FORMAT_R32G32_SINT = 18, DXGI_FORMAT_R32G8X24_TYPELESS = 19, DXGI_FORMAT_D32_FLOAT_S8X24_UINT = 20, DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS = 21, DXGI_FORMAT_X32_TYPELESS_G8X24_UINT = 22, DXGI_FORMAT_R10G10B10A2_TYPELESS = 23, DXGI_FORMAT_R10G10B10A2_UNORM = 24, DXGI_FORMAT_R10G10B10A2_UINT = 25, DXGI_FORMAT_R11G11B10_FLOAT = 26, DXGI_FORMAT_R8G8B8A8_TYPELESS = 27, DXGI_FORMAT_R8G8B8A8_UNORM = 28, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = 29, DXGI_FORMAT_R8G8B8A8_UINT = 30, DXGI_FORMAT_R8G8B8A8_SNORM = 31, DXGI_FORMAT_R8G8B8A8_SINT = 32, DXGI_FORMAT_R16G16_TYPELESS = 33, DXGI_FORMAT_R16G16_FLOAT = 34, DXGI_FORMAT_R16G16_UNORM = 35, DXGI_FORMAT_R16G16_UINT = 36, DXGI_FORMAT_R16G16_SNORM = 37, DXGI_FORMAT_R16G16_SINT = 38, DXGI_FORMAT_R32_TYPELESS = 39, DXGI_FORMAT_D32_FLOAT = 40, DXGI_FORMAT_R32_FLOAT = 41, DXGI_FORMAT_R32_UINT = 42, DXGI_FORMAT_R32_SINT = 43, DXGI_FORMAT_R24G8_TYPELESS = 44, DXGI_FORMAT_D24_UNORM_S8_UINT = 45, DXGI_FORMAT_R24_UNORM_X8_TYPELESS = 46, DXGI_FORMAT_X24_TYPELESS_G8_UINT = 47, DXGI_FORMAT_R8G8_TYPELESS = 48, DXGI_FORMAT_R8G8_UNORM = 49, DXGI_FORMAT_R8G8_UINT = 50, DXGI_FORMAT_R8G8_SNORM = 51, DXGI_FORMAT_R8G8_SINT = 52, DXGI_FORMAT_R16_TYPELESS = 53, DXGI_FORMAT_R16_FLOAT = 54, DXGI_FORMAT_D16_UNORM = 55, DXGI_FORMAT_R16_UNORM = 56, DXGI_FORMAT_R16_UINT = 57, DXGI_FORMAT_R16_SNORM = 58, DXGI_FORMAT_R16_SINT = 59, DXGI_FORMAT_R8_TYPELESS = 60, DXGI_FORMAT_R8_UNORM = 61, DXGI_FORMAT_R8_UINT = 62, DXGI_FORMAT_R8_SNORM = 63, DXGI_FORMAT_R8_SINT = 64, DXGI_FORMAT_A8_UNORM = 65, DXGI_FORMAT_R1_UNORM = 66, DXGI_FORMAT_R9G9B9E5_SHAREDEXP = 67, DXGI_FORMAT_R8G8_B8G8_UNORM = 68, DXGI_FORMAT_G8R8_G8B8_UNORM = 69, DXGI_FORMAT_BC1_TYPELESS = 70, DXGI_FORMAT_BC1_UNORM = 71, DXGI_FORMAT_BC1_UNORM_SRGB = 72, DXGI_FORMAT_BC2_TYPELESS = 73, DXGI_FORMAT_BC2_UNORM = 74, DXGI_FORMAT_BC2_UNORM_SRGB = 75, DXGI_FORMAT_BC3_TYPELESS = 76, DXGI_FORMAT_BC3_UNORM = 77, DXGI_FORMAT_BC3_UNORM_SRGB = 78, DXGI_FORMAT_BC4_TYPELESS = 79, DXGI_FORMAT_BC4_UNORM = 80, DXGI_FORMAT_BC4_SNORM = 81, DXGI_FORMAT_BC5_TYPELESS = 82, DXGI_FORMAT_BC5_UNORM = 83, DXGI_FORMAT_BC5_SNORM = 84, DXGI_FORMAT_B5G6R5_UNORM = 85, DXGI_FORMAT_B5G5R5A1_UNORM = 86, DXGI_FORMAT_B8G8R8A8_UNORM = 87, DXGI_FORMAT_B8G8R8X8_UNORM = 88, DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM = 89, DXGI_FORMAT_B8G8R8A8_TYPELESS = 90, DXGI_FORMAT_B8G8R8A8_UNORM_SRGB = 91, DXGI_FORMAT_B8G8R8X8_TYPELESS = 92, DXGI_FORMAT_B8G8R8X8_UNORM_SRGB = 93, DXGI_FORMAT_BC6H_TYPELESS = 94, DXGI_FORMAT_BC6H_UF16 = 95, DXGI_FORMAT_BC6H_SF16 = 96, DXGI_FORMAT_BC7_TYPELESS = 97, DXGI_FORMAT_BC7_UNORM = 98, DXGI_FORMAT_BC7_UNORM_SRGB = 99, DXGI_FORMAT_AYUV = 100, DXGI_FORMAT_Y410 = 101, DXGI_FORMAT_Y416 = 102, DXGI_FORMAT_NV12 = 103, DXGI_FORMAT_P010 = 104, DXGI_FORMAT_P016 = 105, DXGI_FORMAT_420_OPAQUE = 106, DXGI_FORMAT_YUY2 = 107, DXGI_FORMAT_Y210 = 108, DXGI_FORMAT_Y216 = 109, DXGI_FORMAT_NV11 = 110, DXGI_FORMAT_AI44 = 111, DXGI_FORMAT_IA44 = 112, DXGI_FORMAT_P8 = 113, DXGI_FORMAT_A8P8 = 114, DXGI_FORMAT_B4G4R4A4_UNORM = 115, DXGI_FORMAT_FORCE_UINT = 0xffffffffUL } DXGI_FORMAT; #define EncodeFourCC(x) ((((ui32_t)((x)[0])) ) | \ (((ui32_t)((x)[1])) << 8 ) | \ (((ui32_t)((x)[2])) << 16) | \ (((ui32_t)((x)[3])) << 24) ) static void LoadDDS(const char* name, byte** pic, int* width, int* height, qboolean* hasAlpha, int* glCompressMode, int* numMipmaps, int* piMipmapsAvailable) { int len; unsigned int signature; ddsHeader_t ddsHeader; ddsHeaderDxt10_t* ddsHeaderDxt10 = NULL; fileHandle_t handle; byte* data; int w, h; int minWidth, minHeight; int numMips = 0; int size; int intSize; *pic = NULL; *piMipmapsAvailable = 0; if (width) *width = 0; if (height) *height = 0; // // load the file // len = ri.FS_OpenFile((char*)name, &handle, qtrue, qtrue); if (len < 0) { return; } // // reject files that are too small to hold even a header // if (len < 4 + sizeof(ddsHeader)) { ri.Printf(PRINT_ALL, "File %s is too small to be a DDS file.\n", name); ri.FS_CloseFile(handle); return; } // // reject files that don't start with "DDS " // ri.FS_Read(&signature, sizeof(signature), handle); if (strncmp((const char*)&signature, "DDS ", 4)) { ri.Printf(PRINT_ALL, "File %s is not a DDS file.\n", name); ri.FS_CloseFile(handle); return; } ri.FS_Read(&ddsHeader, sizeof(ddsHeader), handle); ddsHeader.headerSize = LittleLong(ddsHeader.headerSize); ddsHeader.flags = LittleLong(ddsHeader.flags); ddsHeader.width = LittleLong(ddsHeader.width); ddsHeader.height = LittleLong(ddsHeader.height); ddsHeader.numMips = LittleLong(ddsHeader.numMips); ddsHeader.pitchOrFirstMipSize = LittleLong(ddsHeader.pitchOrFirstMipSize); ddsHeader.fourCC = LittleLong(ddsHeader.fourCC); // // Convert DXGI format/FourCC into OpenGL format // if (ddsHeader.fourCC == EncodeFourCC("DXT1")) { intSize = 2; *glCompressMode = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; } else if (ddsHeader.fourCC == EncodeFourCC("DXT2")) { intSize = 4; *glCompressMode = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; } else if (ddsHeader.fourCC == EncodeFourCC("DXT3")) { intSize = 4; *glCompressMode = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; } else if (ddsHeader.fourCC == EncodeFourCC("DXT4")) { intSize = 4; *glCompressMode = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; } else if (ddsHeader.fourCC == EncodeFourCC("DXT5")) { intSize = 4; *glCompressMode = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; } else { ri.FS_CloseFile(handle); return; } minWidth = ddsHeader.width; for (w = 1; w < ddsHeader.width; w *= 2) {} minHeight = ddsHeader.height; for (h = 1; h < ddsHeader.height; h *= 2) {} if (w != ddsHeader.width || h != ddsHeader.height) { ri.FS_CloseFile(handle); if (w == ddsHeader.width) { ri.Printf(PRINT_DEVELOPER, "LoadDDS: Image %s - height not a power of 2\n", name); } else if (h == ddsHeader.height) { ri.Printf(PRINT_DEVELOPER, "LoadDDS: Image %s - width not a power of 2\n", name); } else { ri.Printf(PRINT_DEVELOPER, "LoadDDS: Image %s - width and height not a powers of 2\n", name); } return; } // // Parse width and height // if (!minWidth) { minWidth = 1; } *width = minWidth; if (!minHeight) { minHeight = 1; } *height = minHeight; *hasAlpha = ddsHeader.fourCC != EncodeFourCC("DXT1"); numMips = ddsHeader.numMips; if (!numMips) { numMips = 1; } *piMipmapsAvailable = numMips; if (*numMipmaps) { *numMipmaps = numMips; } size = ddsHeader.pitchOrFirstMipSize; if (*piMipmapsAvailable > 1) { size = intSize * ddsHeader.pitchOrFirstMipSize; } *pic = ri.Malloc(size); ri.FS_Read(*pic, size, handle); ri.FS_CloseFile(handle); } /* ========================================================= TARGA LOADING ========================================================= */ /* ============= LoadTGA ============= */ static void LoadTGA ( const char *name, byte **pic, int *width, int *height) { int columns, rows, numPixels; byte *pixbuf; int row, column; byte *buf_p; byte *buffer; TargaHeader targa_header; byte *targa_rgba; *pic = NULL; // // load the file // ri.FS_ReadFile ( ( char * ) name, (void **)&buffer); if (!buffer) { return; } buf_p = buffer; targa_header.id_length = *buf_p++; targa_header.colormap_type = *buf_p++; targa_header.image_type = *buf_p++; targa_header.colormap_index = LittleShort ( *(short *)buf_p ); buf_p += 2; targa_header.colormap_length = LittleShort ( *(short *)buf_p ); 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++; if (targa_header.image_type!=2 && targa_header.image_type!=10 && targa_header.image_type != 3 ) { ri.Error (ERR_DROP, "LoadTGA: Only type 2 (RGB), 3 (gray), and 10 (RGB) TGA images supported\n"); } if ( targa_header.colormap_type != 0 ) { ri.Error( ERR_DROP, "LoadTGA: colormaps not supported\n" ); } if ( ( targa_header.pixel_size != 32 && targa_header.pixel_size != 24 ) && targa_header.image_type != 3 ) { ri.Error (ERR_DROP, "LoadTGA: Only 32 or 24 bit images supported (no colormaps)\n"); } columns = targa_header.width; rows = targa_header.height; numPixels = columns * rows; if (width) *width = columns; if (height) *height = rows; targa_rgba = ri.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 || targa_header.image_type == 3 ) { // Uncompressed RGB or gray scale image for(row=rows-1; row>=0; row--) { pixbuf = targa_rgba + row*columns*4; for(column=0; column=0; row--) { pixbuf = targa_rgba + row*columns*4; for(column=0; column0) row--; else goto breakOut; pixbuf = targa_rgba + row*columns*4; } } } else { // non run-length packet for(j=0;j0) row--; else goto breakOut; pixbuf = targa_rgba + row*columns*4; } } } } breakOut:; } } #if 0 // TTimo: this is the chunk of code to ensure a behavior that meets TGA specs // bk0101024 - fix from Leonardo // bit 5 set => top-down if (targa_header.attributes & 0x20) { unsigned char *flip = (unsigned char*)malloc (columns*4); unsigned char *src, *dst; for (row = 0; row < rows/2; row++) { src = targa_rgba + row * 4 * columns; dst = targa_rgba + (rows - row - 1) * 4 * columns; memcpy (flip, src, columns*4); memcpy (src, dst, columns*4); memcpy (dst, flip, columns*4); } free (flip); } #endif // instead we just print a warning if (targa_header.attributes & 0x20) { ri.Printf( PRINT_WARNING, "WARNING: '%s' TGA file header declares top-down image, ignoring\n", name); } ri.FS_FreeFile (buffer); } /* Catching errors, as done in libjpeg's example.c */ typedef struct q_jpeg_error_mgr_s { struct jpeg_error_mgr pub; /* "public" fields */ jmp_buf setjmp_buffer; /* for return to caller */ } q_jpeg_error_mgr_t; static void R_JPGErrorExit(j_common_ptr cinfo) { char buffer[JMSG_LENGTH_MAX]; /* cinfo->err really points to a q_jpeg_error_mgr_s struct, so coerce pointer */ q_jpeg_error_mgr_t *jerr = (q_jpeg_error_mgr_t *)cinfo->err; (*cinfo->err->format_message) (cinfo, buffer); ri.Printf(PRINT_ALL, "Error: %s", buffer); /* Return control to the setjmp point */ longjmp(jerr->setjmp_buffer, 1); } static void R_JPGOutputMessage(j_common_ptr cinfo) { char buffer[JMSG_LENGTH_MAX]; /* Create the message */ (*cinfo->err->format_message) (cinfo, buffer); /* Send it to stderr, adding a newline */ ri.Printf(PRINT_ALL, "%s\n", buffer); } static void LoadJPG( const char *filename, unsigned char **pic, int *width, int *height ) { /* This struct contains the JPEG decompression parameters and pointers to * working space (which is allocated as needed by the JPEG library). */ struct jpeg_decompress_struct cinfo; /* We use our private extension JPEG error handler. * Note that this struct must live as long as the main JPEG parameter * struct, to avoid dangling-pointer problems. */ /* This struct represents a JPEG error handler. It is declared separately * because applications often want to supply a specialized error handler * (see the second half of this file for an example). But here we just * take the easy way out and use the standard error handler, which will * print a message on stderr and call exit() if compression fails. * Note that this struct must live as long as the main JPEG parameter * struct, to avoid dangling-pointer problems. */ q_jpeg_error_mgr_t jerr; /* More stuff */ JSAMPARRAY buffer; /* Output row buffer */ int row_stride; /* physical row width in output buffer */ unsigned int pixelcount, memcount; unsigned int sindex, dindex; unsigned char *out; byte* fbuffer; byte* buf; int len; /* In this example we want to open the input file before doing anything else, * so that the setjmp() error recovery below can assume the file is open. * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that * requires it in order to read binary files. */ len = ri.FS_ReadFile ( ( char * ) filename, (void **)&fbuffer); if (!fbuffer) { return; } /* Step 1: allocate and initialize JPEG decompression object */ /* We have to set up the error handler first, in case the initialization * step fails. (Unlikely, but it could happen if you are out of memory.) * This routine fills in the contents of struct jerr, and returns jerr's * address which we place into the link field in cinfo. */ cinfo.err = jpeg_std_error(&jerr.pub); cinfo.err->error_exit = R_JPGErrorExit; cinfo.err->output_message = R_JPGOutputMessage; /* Establish the setjmp return context for R_JPGErrorExit to use. */ if (setjmp(jerr.setjmp_buffer)) { /* If we get here, the JPEG code has signaled an error. * We need to clean up the JPEG object, close the input file, and return. */ jpeg_destroy_decompress(&cinfo); ri.FS_FreeFile(fbuffer); /* Append the filename to the error for easier debugging */ ri.Printf(PRINT_ALL, ", loading file %s\n", filename); return; } /* Now we can initialize the JPEG decompression object. */ jpeg_create_decompress(&cinfo); /* Step 2: specify data source (eg, a file) */ jpeg_mem_src(&cinfo, fbuffer, len); /* Step 3: read file parameters with jpeg_read_header() */ (void) jpeg_read_header(&cinfo, TRUE); /* We can ignore the return value from jpeg_read_header since * (a) suspension is not possible with the stdio data source, and * (b) we passed TRUE to reject a tables-only JPEG file as an error. * See libjpeg.doc for more info. */ /* Step 4: set parameters for decompression */ /* * Make sure it always converts images to RGB color space. This will * automatically convert 8-bit greyscale images to RGB as well. */ cinfo.out_color_space = JCS_RGB; /* In this example, we don't need to change any of the defaults set by * jpeg_read_header(), so we do nothing here. */ /* Step 5: Start decompressor */ (void) jpeg_start_decompress(&cinfo); /* We can ignore the return value since suspension is not possible * with the stdio data source. */ /* We may need to do some setup of our own at this point before reading * the data. After jpeg_start_decompress() we have the correct scaled * output image dimensions available, as well as the output colormap * if we asked for color quantization. * In this example, we need to make an output work buffer of the right size. */ /* JSAMPLEs per row in output buffer */ pixelcount = cinfo.output_width * cinfo.output_height; if (!cinfo.output_width || !cinfo.output_height || ((pixelcount * 4) / cinfo.output_width) / 4 != cinfo.output_height || pixelcount > 0x1FFFFFFF || cinfo.output_components != 3 ) { // Free the memory to make sure we don't leak memory ri.FS_FreeFile(fbuffer); jpeg_destroy_decompress(&cinfo); ri.Error(ERR_DROP, "LoadJPG: %s has an invalid image format: %dx%d*4=%d, components: %d", filename, cinfo.output_width, cinfo.output_height, pixelcount * 4, cinfo.output_components); } memcount = pixelcount * 4; row_stride = cinfo.output_width * cinfo.output_components; out = ri.Malloc(memcount); *width = cinfo.output_width; *height = cinfo.output_height; /* Step 6: while (scan lines remain to be read) */ /* jpeg_read_scanlines(...); */ /* Here we use the library's state variable cinfo.output_scanline as the * loop counter, so that we don't have to keep track ourselves. */ while (cinfo.output_scanline < cinfo.output_height) { /* jpeg_read_scanlines expects an array of pointers to scanlines. * Here the array is only one element long, but you could ask for * more than one scanline at a time if that's more convenient. */ buf = ((out + (row_stride * cinfo.output_scanline))); buffer = &buf; (void)jpeg_read_scanlines(&cinfo, buffer, 1); } buf = out; // Expand from RGB to RGBA sindex = pixelcount * cinfo.output_components; dindex = memcount; do { buf[--dindex] = 255; buf[--dindex] = buf[--sindex]; buf[--dindex] = buf[--sindex]; buf[--dindex] = buf[--sindex]; } while (sindex); *pic = out; /* Step 7: Finish decompression */ (void) jpeg_finish_decompress(&cinfo); /* We can ignore the return value since suspension is not possible * with the stdio data source. */ /* Step 8: Release JPEG decompression object */ /* This is an important step since it will release a good deal of memory. */ jpeg_destroy_decompress(&cinfo); /* After finish_decompress, we can close the input file. * Here we postpone it until after no more JPEG errors are possible, * so as to simplify the setjmp error logic above. (Actually, I don't * think that jpeg_destroy can do an error exit, but why assume anything...) */ ri.FS_FreeFile (fbuffer); /* At this point you may want to check to see whether any corrupt-data * warnings occurred (test whether jerr.pub.num_warnings is nonzero). */ /* And we're done! */ } /* Expanded data destination object for stdio output */ typedef struct { struct jpeg_destination_mgr pub; /* public fields */ byte* outfile; /* target stream */ int size; } my_destination_mgr; typedef my_destination_mgr * my_dest_ptr; /* * Initialize destination --- called by jpeg_start_compress * before any data is actually written. */ void init_destination (j_compress_ptr cinfo) { my_dest_ptr dest = (my_dest_ptr) cinfo->dest; dest->pub.next_output_byte = dest->outfile; dest->pub.free_in_buffer = dest->size; } /* * Empty the output buffer --- called whenever buffer fills up. * * In typical applications, this should write the entire output buffer * (ignoring the current state of next_output_byte & free_in_buffer), * reset the pointer & count to the start of the buffer, and return TRUE * indicating that the buffer has been dumped. * * In applications that need to be able to suspend compression due to output * overrun, a FALSE return indicates that the buffer cannot be emptied now. * In this situation, the compressor will return to its caller (possibly with * an indication that it has not accepted all the supplied scanlines). The * application should resume compression after it has made more room in the * output buffer. Note that there are substantial restrictions on the use of * suspension --- see the documentation. * * When suspending, the compressor will back up to a convenient restart point * (typically the start of the current MCU). next_output_byte & free_in_buffer * indicate where the restart point will be if the current call returns FALSE. * Data beyond this point will be regenerated after resumption, so do not * write it out when emptying the buffer externally. */ boolean empty_output_buffer (j_compress_ptr cinfo) { return TRUE; } #if 0 /* * Compression initialization. * Before calling this, all parameters and a data destination must be set up. * * We require a write_all_tables parameter as a failsafe check when writing * multiple datastreams from the same compression object. Since prior runs * will have left all the tables marked sent_table=TRUE, a subsequent run * would emit an abbreviated stream (no tables) by default. This may be what * is wanted, but for safety's sake it should not be the default behavior: * programmers should have to make a deliberate choice to emit abbreviated * images. Therefore the documentation and examples should encourage people * to pass write_all_tables=TRUE; then it will take active thought to do the * wrong thing. */ GLOBAL void jpeg_start_compress (j_compress_ptr cinfo, boolean write_all_tables) { if (cinfo->global_state != CSTATE_START) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); if (write_all_tables) jpeg_suppress_tables(cinfo, FALSE); /* mark all tables to be written */ /* (Re)initialize error mgr and destination modules */ (*cinfo->err->reset_error_mgr) ((j_common_ptr) cinfo); (*cinfo->dest->init_destination) (cinfo); /* Perform master selection of active modules */ jinit_compress_master(cinfo); /* Set up for the first pass */ (*cinfo->master->prepare_for_pass) (cinfo); /* Ready for application to drive first pass through jpeg_write_scanlines * or jpeg_write_raw_data. */ cinfo->next_scanline = 0; cinfo->global_state = (cinfo->raw_data_in ? CSTATE_RAW_OK : CSTATE_SCANNING); } /* * Write some scanlines of data to the JPEG compressor. * * The return value will be the number of lines actually written. * This should be less than the supplied num_lines only in case that * the data destination module has requested suspension of the compressor, * or if more than image_height scanlines are passed in. * * Note: we warn about excess calls to jpeg_write_scanlines() since * this likely signals an application programmer error. However, * excess scanlines passed in the last valid call are *silently* ignored, * so that the application need not adjust num_lines for end-of-image * when using a multiple-scanline buffer. */ GLOBAL JDIMENSION jpeg_write_scanlines (j_compress_ptr cinfo, JSAMPARRAY scanlines, JDIMENSION num_lines) { JDIMENSION row_ctr, rows_left; if (cinfo->global_state != CSTATE_SCANNING) ERREXIT1(cinfo, JERR_BAD_STATE, cinfo->global_state); if (cinfo->next_scanline >= cinfo->image_height) WARNMS(cinfo, JWRN_TOO_MUCH_DATA); /* Call progress monitor hook if present */ if (cinfo->progress != NULL) { cinfo->progress->pass_counter = (long) cinfo->next_scanline; cinfo->progress->pass_limit = (long) cinfo->image_height; (*cinfo->progress->progress_monitor) ((j_common_ptr) cinfo); } /* Give master control module another chance if this is first call to * jpeg_write_scanlines. This lets output of the frame/scan headers be * delayed so that application can write COM, etc, markers between * jpeg_start_compress and jpeg_write_scanlines. */ if (cinfo->master->call_pass_startup) (*cinfo->master->pass_startup) (cinfo); /* Ignore any extra scanlines at bottom of image. */ rows_left = cinfo->image_height - cinfo->next_scanline; if (num_lines > rows_left) num_lines = rows_left; row_ctr = 0; (*cinfo->main->process_data) (cinfo, scanlines, &row_ctr, num_lines); cinfo->next_scanline += row_ctr; return row_ctr; } /* * Terminate destination --- called by jpeg_finish_compress * after all data has been written. Usually needs to flush buffer. * * NB: *not* called by jpeg_abort or jpeg_destroy; surrounding * application must deal with any cleanup that should happen even * for error exit. */ static int hackSize; void term_destination (j_compress_ptr cinfo) { my_dest_ptr dest = (my_dest_ptr) cinfo->dest; size_t datacount = dest->size - dest->pub.free_in_buffer; hackSize = datacount; } /* * Prepare for output to a stdio stream. * The caller must have already opened the stream, and is responsible * for closing it after finishing compression. */ void jpegDest (j_compress_ptr cinfo, byte* outfile, int size) { my_dest_ptr dest; /* The destination object is made permanent so that multiple JPEG images * can be written to the same file without re-executing jpeg_stdio_dest. * This makes it dangerous to use this manager and a different destination * manager serially with the same JPEG object, because their private object * sizes may be different. Caveat programmer. */ if (cinfo->dest == NULL) { /* first time for this JPEG object? */ cinfo->dest = (struct jpeg_destination_mgr *) (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(my_destination_mgr)); } dest = (my_dest_ptr) cinfo->dest; dest->pub.init_destination = init_destination; dest->pub.empty_output_buffer = empty_output_buffer; dest->pub.term_destination = term_destination; dest->outfile = outfile; dest->size = size; } void SaveJPG(char * filename, int quality, int image_width, int image_height, unsigned char *image_buffer) { /* This struct contains the JPEG compression parameters and pointers to * working space (which is allocated as needed by the JPEG library). * It is possible to have several such structures, representing multiple * compression/decompression processes, in existence at once. We refer * to any one struct (and its associated working data) as a "JPEG object". */ struct jpeg_compress_struct cinfo; /* This struct represents a JPEG error handler. It is declared separately * because applications often want to supply a specialized error handler * (see the second half of this file for an example). But here we just * take the easy way out and use the standard error handler, which will * print a message on stderr and call exit() if compression fails. * Note that this struct must live as long as the main JPEG parameter * struct, to avoid dangling-pointer problems. */ struct jpeg_error_mgr jerr; /* More stuff */ JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */ int row_stride; /* physical row width in image buffer */ unsigned char *out; /* Step 1: allocate and initialize JPEG compression object */ /* We have to set up the error handler first, in case the initialization * step fails. (Unlikely, but it could happen if you are out of memory.) * This routine fills in the contents of struct jerr, and returns jerr's * address which we place into the link field in cinfo. */ cinfo.err = jpeg_std_error(&jerr); /* Now we can initialize the JPEG compression object. */ jpeg_CreateDecompress(&cinfo); /* Step 2: specify data destination (eg, a file) */ /* Note: steps 2 and 3 can be done in either order. */ /* Here we use the library-supplied code to send compressed data to a * stdio stream. You can also write your own code to do something else. * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that * requires it in order to write binary files. */ out = ri.Hunk_AllocateTempMemory(image_width*image_height*4); jpegDest(&cinfo, out, image_width*image_height*4); /* Step 3: set parameters for compression */ /* First we supply a description of the input image. * Four fields of the cinfo struct must be filled in: */ cinfo.image_width = image_width; /* image width and height, in pixels */ cinfo.image_height = image_height; cinfo.input_components = 4; /* # of color components per pixel */ cinfo.in_color_space = JCS_RGB; /* colorspace of input image */ /* Now use the library's routine to set default compression parameters. * (You must set at least cinfo.in_color_space before calling this, * since the defaults depend on the source color space.) */ jpeg_set_defaults(&cinfo); /* Now you can set any non-default parameters you wish to. * Here we just illustrate the use of quality (quantization table) scaling: */ jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */); /* Step 4: Start compressor */ /* TRUE ensures that we will write a complete interchange-JPEG file. * Pass TRUE unless you are very sure of what you're doing. */ jpeg_start_compress(&cinfo, TRUE); /* Step 5: while (scan lines remain to be written) */ /* jpeg_write_scanlines(...); */ /* Here we use the library's state variable cinfo.next_scanline as the * loop counter, so that we don't have to keep track ourselves. * To keep things simple, we pass one scanline per call; you can pass * more if you wish, though. */ row_stride = image_width * 4; /* JSAMPLEs per row in image_buffer */ while (cinfo.next_scanline < cinfo.image_height) { /* jpeg_write_scanlines expects an array of pointers to scanlines. * Here the array is only one element long, but you could pass * more than one scanline at a time if that's more convenient. */ row_pointer[0] = & image_buffer[((cinfo.image_height-1)*row_stride)-cinfo.next_scanline * row_stride]; (void) jpeg_write_scanlines(&cinfo, row_pointer, 1); } /* Step 6: Finish compression */ jpeg_finish_compress(&cinfo); /* After finish_compress, we can close the output file. */ ri.ri.FS_WriteFile( filename, out, hackSize ); ri.Hunk_FreeTempMemory(out); /* Step 7: release JPEG compression object */ /* This is an important step since it will release a good deal of memory. */ jpeg_destroy_compress(&cinfo); /* And we're done! */ } #endif //=================================================================== /* ================= R_LoadImage Loads any of the supported image types into a cannonical 32 bit format. ================= */ static void R_LoadImage(const char* name, byte** pic, int* width, int* height, qboolean* hasAlpha, int* glCompressMode, int* numMipmaps, int* piMipmapsAvailable) { size_t len; char tempName[MAX_STRING_TOKENS + 1]; char altname[MAX_QPATH]; *hasAlpha = qfalse; *glCompressMode = 0; *pic = NULL; *width = 0; *height = 0; len = strlen(name); if (len < 5) { return; } strcpy(altname, name); len = strlen(altname); if (glConfig.textureCompression == TC_S3TC || glConfig.textureCompression == TC_S3TC_ARB) { len = strlen(altname); altname[len - 3] = 'd'; altname[len - 2] = 'd'; altname[len - 1] = 's'; LoadDDS(altname, pic, width, height, hasAlpha, glCompressMode, numMipmaps, piMipmapsAvailable); } if (!*pic) { if (!Q_stricmp(name + len - 4, ".tga") || !Q_stricmp(name + len - 4, ".jpg")) { if (r_loadjpg->integer) { len = strlen(altname); altname[len - 3] = 'j'; altname[len - 2] = 'p'; altname[len - 1] = 'g'; // try jpg first LoadJPG(altname, pic, width, height); } if (!*pic) { altname[len - 3] = 't'; altname[len - 2] = 'g'; altname[len - 1] = 'a'; LoadTGA(altname, pic, width, height); } *piMipmapsAvailable = 1; } else if (!Q_stricmp(name + len - 4, ".pcx")) { LoadPCX32(name, pic, width, height); *piMipmapsAvailable = 1; } else if (!Q_stricmp(name + len - 4, ".bmp")) { LoadBMP(name, pic, width, height); *piMipmapsAvailable = 1; } else if (!Q_stricmp(name + len - 4, ".jpg")) { LoadJPG(name, pic, width, height); *piMipmapsAvailable = 1; } else if (!Q_stricmp(name + len - 4, ".gst")) { LoadGHOST(name, pic, width, height); *piMipmapsAvailable = 0; } } if (tr.registered) { Com_sprintf(tempName, sizeof(tempName), "n%s", name); ri.UI_LoadResource(tempName); } } /* =============== R_FindImageFile Finds or loads the given image. Returns NULL if it fails, not a default image. ============== */ image_t* R_FindImageFileOld(const char* name, qboolean mipmap, qboolean allowPicmip, qboolean force32bit, int glWrapClampModeX, int glWrapClampModeY) { image_t *image; int width, height; byte *pic; int len; qboolean hasAlpha; int glCompressMode; int numMipmaps; int iMipmapsAvailable; long hash; if (!name) { return NULL; } hash = generateHashValue(name); // // see if the image is already loaded // for (image = hashTable[hash]; image; image = image->next) { if (!strcmp(name, image->imgName)) { // the white image can be used with any set of parms, but other mismatches are errors if (strcmp(name, "*white")) { if ((image->numMipmaps && !mipmap) || (!image->numMipmaps && mipmap)) { ri.Printf(PRINT_DEVELOPER, "WARNING: reused image %s with mixed mipmap parm\n", name); } if (image->allowPicmip != allowPicmip) { ri.Printf(PRINT_DEVELOPER, "WARNING: reused image %s with mixed allowPicmip parm\n", name); } if (image->wrapClampModeX != glWrapClampModeX || image->wrapClampModeY != glWrapClampModeY) { ri.Printf(PRINT_ALL, "WARNING: reused image %s with mixed glWrapClampMode parm\n", name); } } if (image->r_sequence != -1) { image->r_sequence = r_sequencenumber; } return image; } } // // load the pic from disk // numMipmaps = mipmap; iMipmapsAvailable = 0; R_LoadImage(name, &pic, &width, &height, &hasAlpha, &glCompressMode, &numMipmaps, &iMipmapsAvailable); if (pic == NULL) { return NULL; } image = R_CreateImageOld( name, pic, width, height, numMipmaps, iMipmapsAvailable, allowPicmip, force32bit, hasAlpha, glCompressMode, glWrapClampModeX, glWrapClampModeY); len = strlen(name); if (len > 4 && !strcmp(&name[len - 4], ".gst")) { R_SetGhostImage(name, image); } ri.Free(pic); return image; } /* ================ R_RefreshImageFile ================ */ image_t* R_RefreshImageFileOld(const char* name, qboolean mipmap, qboolean allowPicmip, qboolean force32bit, int glWrapClampModeX, int glWrapClampModeY) { char imagename[64]; image_t* image; long hash; if (!name) { return NULL; } strncpy(imagename, name, ARRAY_LEN(imagename)); hash = generateHashValue(name); image = hashTable[hash]; if (image) { while (strcmp(name, image->imgName)) { image = image->next; if (!image) { return R_FindImageFileOld( imagename, mipmap, allowPicmip, force32bit, glWrapClampModeX, glWrapClampModeY ); } } R_FreeImage(image); } return R_FindImageFileOld( imagename, mipmap, allowPicmip, force32bit, glWrapClampModeX, glWrapClampModeY ); } /* ================ R_ImageExists ================ */ qboolean R_ImageExists(const char* name) { image_t* image; long int hash; if (name) { hash = generateHashValue(name); image = hashTable[hash]; if (hash) { for (; image != NULL; image = image->next) { if (!strcmp(name, image->imgName)) { return qtrue; } } } } return qfalse; } /* ================ R_CreateDlightImage ================ */ #define DLIGHT_SIZE 32 static void R_CreateDlightImage( void ) { int x,y; byte data[DLIGHT_SIZE][DLIGHT_SIZE][4]; int b; // make a centered inverse-square falloff blob for dynamic lighting for (x=0 ; x 255) { b = 255; } else if ( b < 75 ) { b = 0; } data[y][x][0] = data[y][x][1] = data[y][x][2] = b; data[y][x][3] = 255; } } tr.dlightImage = R_CreateImageOld("*dlight", (byte *)data, DLIGHT_SIZE, DLIGHT_SIZE, 0, 1, qfalse, qfalse, qfalse, qfalse, GL_CLAMP, GL_CLAMP); tr.dlightImage->r_sequence = -1; } /* ================== R_CreateDefaultImage ================== */ #define DEFAULT_SIZE 16 static void R_CreateDefaultImage( void ) { int x; byte data[DEFAULT_SIZE][DEFAULT_SIZE][4]; // the default image will be a box, to allow you to see the mapping coordinates Com_Memset( data, 32, sizeof( data ) ); for ( x = 0 ; x < DEFAULT_SIZE ; x++ ) { data[0][x][0] = data[0][x][1] = data[0][x][2] = data[0][x][3] = 255; data[x][0][0] = data[x][0][1] = data[x][0][2] = data[x][0][3] = 255; data[DEFAULT_SIZE-1][x][0] = data[DEFAULT_SIZE-1][x][1] = data[DEFAULT_SIZE-1][x][2] = data[DEFAULT_SIZE-1][x][3] = 255; data[x][DEFAULT_SIZE-1][0] = data[x][DEFAULT_SIZE-1][1] = data[x][DEFAULT_SIZE-1][2] = data[x][DEFAULT_SIZE-1][3] = 255; } tr.defaultImage = R_CreateImageOld("*default", (byte *)data, DEFAULT_SIZE, DEFAULT_SIZE, 1, 1, qfalse, qfalse, qfalse, qfalse, GL_REPEAT, GL_REPEAT); tr.defaultImage->r_sequence = -1; } /* ================== R_CreateBuiltinImages ================== */ void R_CreateBuiltinImages(void) { int x, y; int i; byte lightmap_buffer[LIGHTMAP_SIZE * LIGHTMAP_SIZE * 4]; byte data[DEFAULT_SIZE][DEFAULT_SIZE][4]; R_CreateDefaultImage(); // we use a solid white image instead of disabling texturing Com_Memset( data, 255, sizeof( data ) ); tr.whiteImage = R_CreateImageOld("*white", (byte *)data, 8, 8, 0, 1, qfalse, qfalse, qfalse, qfalse, GL_REPEAT, GL_REPEAT); tr.whiteImage->r_sequence = -1; // with overbright bits active, we need an image which is some fraction of full color, // for default lightmaps, etc for (x=0 ; xr_sequence = -1; } tr.identityLightImage = R_CreateImageOld("*identityLight", (byte *)data, 8, 8, 0, 1, qfalse, qfalse, qfalse, qfalse, GL_REPEAT, GL_REPEAT); tr.identityLightImage->r_sequence = -1; tr.scratchImage = R_CreateImageOld("*scratch", (byte*)data, DEFAULT_SIZE, DEFAULT_SIZE, 0, 1, r_picmip->integer, qfalse, qfalse, qfalse, GL_CLAMP, GL_CLAMP); tr.scratchImage->r_sequence = -1; R_CreateDlightImage(); } /* =============== R_SetColorMappings =============== */ void R_SetColorMappings( void ) { int i, j; float g; int inf; int shift; // setup the overbright lighting tr.overbrightBits = r_overBrightBits->integer; if ( !glConfig.deviceSupportsGamma ) { tr.overbrightBits = 0; // need hardware gamma for overbright } // never overbright in windowed mode if ( !glConfig.isFullscreen ) { tr.overbrightBits = 0; } // allow 2 overbright bits in 24 bit, but only 1 in 16 bit if ( glConfig.colorBits > 16 ) { if ( tr.overbrightBits > 2 ) { tr.overbrightBits = 2; } } else { if ( tr.overbrightBits > 1 ) { tr.overbrightBits = 1; } } if ( tr.overbrightBits < 0 ) { tr.overbrightBits = 0; } tr.overbrightShift = r_mapOverBrightBits->integer - tr.overbrightBits; tr.overbrightMult = (float)(1 << tr.overbrightShift); tr.identityLight = 1.0f / (1 << tr.overbrightBits); tr.identityLightByte = 255 * tr.identityLight; if ( r_intensity->value <= 1 ) { ri.Cvar_Set( "r_intensity", "1" ); } if ( r_gamma->value < 0.5f ) { ri.Cvar_Set( "r_gamma", "0.5" ); } else if ( r_gamma->value > 3.0f ) { ri.Cvar_Set( "r_gamma", "3.0" ); } g = r_gamma->value; if (!glConfig.deviceSupportsGamma && g != 1.0) { tr.needsLightScale = qtrue; } else if (r_intensity->value != 1.0) { tr.needsLightScale = qtrue; } else { tr.needsLightScale = qfalse; } shift = tr.overbrightBits; for ( i = 0; i < 256; i++ ) { if ( g == 1 ) { inf = i; } else { inf = 255 * pow ( i/255.0f, 1.0f / g ) + 0.5f; } inf <<= shift; if (inf < 0) { inf = 0; } if (inf > 255) { inf = 255; } s_gammatable[i] = inf; } for (i=0 ; i<256 ; i++) { j = i * r_intensity->value; if (j > 255) { j = 255; } s_intensitytable[i] = j; } if ( glConfig.deviceSupportsGamma ) { GLimp_SetGamma( s_gammatable, s_gammatable, s_gammatable ); } } /* =============== R_InitImages =============== */ void R_InitImages( void ) { Com_Memset(hashTable, 0, sizeof(hashTable)); // clear images Com_Memset(tr.images, 0, sizeof(tr.images)); tr.numImages = 0; // build brightness translation tables R_SetColorMappings(); // create default texture and white texture R_CreateBuiltinImages(); } /* =============== R_DeleteImageFromHash =============== */ void R_DeleteImageFromHash(image_t* image) { image_t* current; image_t* prev; int hash; hash = generateHashValue(image->imgName); current = hashTable[hash]; prev = NULL; while (current) { if (image == current) { if (prev) { prev->next = current->next; } else { hashTable[hash] = current->next; } return; } prev = current; current = current->next; } } /* =============== R_FreeImage =============== */ void R_FreeImage(image_t* image) { if (image->texnum) { qglDeleteTextures(1, &image->texnum); } R_DeleteImageFromHash(image); memset(image, 0, sizeof(image_t)); } /* =============== R_DeleteTextures =============== */ void R_DeleteTextures( void ) { int i; for ( i=0; iimgName, strlen(image->imgName), stat_file); ri.FS_Write(", ", 2, stat_file); // Write the number of bytes (in KiB) Q_snprintf(str_buffer, sizeof(str_buffer), "%d", image->bytesUsed >> 10); ri.FS_Write(str_buffer, strlen(str_buffer), stat_file); ri.FS_Write(", ", 2, stat_file); // Write the sequence Q_snprintf(str_buffer, sizeof(str_buffer), "%d", image->r_sequence); ri.FS_Write(str_buffer, strlen(str_buffer), stat_file); ri.FS_Write(", ", 2, stat_file); } } /* =============== R_CountTextureMemory =============== */ int R_CountTextureMemory() { int total_bytes; int i; R_DumpTextureMemory(); total_bytes = 0; for (i = 0; i < tr.numImages; i++) { total_bytes = tr.images[i].bytesUsed; } return total_bytes; } /* =============== R_FreeUnusedImages =============== */ void R_FreeUnusedImages() { int i; for (i = 0; i < tr.numImages; i++) { image_t* image = &tr.images[i]; if (image->imgName[0] && image->r_sequence != r_sequencenumber && image->r_sequence != -1) { R_FreeImage(image); } } } /* ============================================================================ SKINS ============================================================================ */ /* ================== CommaParse This is unfortunate, but the skin files aren't compatable with our normal parsing rules. ================== */ static char *CommaParse( char **data_p ) { int c = 0, len; char *data; static char com_token[MAX_TOKEN_CHARS]; data = *data_p; len = 0; com_token[0] = 0; // make sure incoming data is valid if ( !data ) { *data_p = NULL; return com_token; } while ( 1 ) { // skip whitespace while( (c = *data) <= ' ') { if( !c ) { break; } data++; } c = *data; // skip double slash comments if ( c == '/' && data[1] == '/' ) { while (*data && *data != '\n') data++; } // skip /* */ comments else if ( c=='/' && data[1] == '*' ) { while ( *data && ( *data != '*' || data[1] != '/' ) ) { data++; } if ( *data ) { data += 2; } } else { break; } } if ( c == 0 ) { return ""; } // handle quoted strings if (c == '\"') { data++; while (1) { c = *data++; if (c=='\"' || !c) { com_token[len] = 0; *data_p = ( char * ) data; return com_token; } if (len < MAX_TOKEN_CHARS) { com_token[len] = c; len++; } } } // parse a regular word do { if (len < MAX_TOKEN_CHARS) { com_token[len] = c; len++; } data++; c = *data; } while (c>32 && c != ',' ); if (len == MAX_TOKEN_CHARS) { // Com_Printf ("Token exceeded %i chars, discarded.\n", MAX_TOKEN_CHARS); len = 0; } com_token[len] = 0; *data_p = ( char * ) data; return com_token; } /* =============== RE_RegisterSkin =============== */ qhandle_t RE_RegisterSkin( const char *name ) { qhandle_t hSkin; skin_t *skin; skinSurface_t *surf; char *text, *text_p; char *token; char surfName[MAX_QPATH]; if ( !name || !name[0] ) { ri.Printf(PRINT_ALL, "Empty name passed to RE_RegisterSkin\n" ); return 0; } if ( strlen( name ) >= MAX_QPATH ) { ri.Printf(PRINT_ALL, "Skin name exceeds MAX_QPATH\n" ); return 0; } // see if the skin is already loaded for ( hSkin = 1; hSkin < tr.numSkins ; hSkin++ ) { skin = tr.skins[hSkin]; if ( !Q_stricmp( skin->name, name ) ) { if( skin->numSurfaces == 0 ) { return 0; // default skin } return hSkin; } } // allocate a new skin if ( tr.numSkins == MAX_SKINS ) { ri.Printf( PRINT_WARNING, "WARNING: RE_RegisterSkin( '%s' ) MAX_SKINS hit\n", name ); return 0; } tr.numSkins++; skin = ri.Hunk_Alloc( sizeof( skin_t ), h_dontcare ); tr.skins[hSkin] = skin; Q_strncpyz( skin->name, name, sizeof( skin->name ) ); skin->numSurfaces = 0; // make sure the render thread is stopped R_IssuePendingRenderCommands(); // If not a .skin file, load as a single shader if ( strcmp( name + strlen( name ) - 5, ".skin" ) ) { skin->numSurfaces = 1; skin->surfaces[0] = ri.Hunk_Alloc( sizeof(skin->surfaces[0]), h_dontcare); skin->surfaces[0]->shader = R_FindShader( name, LIGHTMAP_NONE, qtrue, qfalse, qfalse, qfalse ); return hSkin; } // load and parse the skin file ri.FS_ReadFile( name, (void **)&text ); if ( !text ) { return 0; } text_p = text; while ( text_p && *text_p ) { // get surface name token = CommaParse( &text_p ); Q_strncpyz( surfName, token, sizeof( surfName ) ); if ( !token[0] ) { break; } // lowercase the surface name so skin compares are faster Q_strlwr( surfName ); if ( *text_p == ',' ) { text_p++; } if ( strstr( token, "tag_" ) ) { continue; } // parse the shader name token = CommaParse( &text_p ); surf = skin->surfaces[ skin->numSurfaces ] = ri.Hunk_Alloc( sizeof( *skin->surfaces[0] ), h_dontcare ); Q_strncpyz( surf->name, surfName, sizeof( surf->name ) ); surf->shader = R_FindShader( token, LIGHTMAP_NONE, qtrue, qfalse, qfalse, qfalse ); skin->numSurfaces++; } ri.FS_FreeFile( text ); // never let a skin have 0 shaders if ( skin->numSurfaces == 0 ) { return 0; // use default skin } return hSkin; } /* =============== R_GetSkinByHandle =============== */ skin_t *R_GetSkinByHandle( qhandle_t hSkin ) { if ( hSkin < 1 || hSkin >= tr.numSkins ) { return tr.skins[0]; } return tr.skins[ hSkin ]; } /* =============== R_SkinList_f =============== */ void R_SkinList_f( void ) { int i, j; skin_t *skin; ri.Printf (PRINT_ALL, "------------------\n"); for ( i = 0 ; i < tr.numSkins ; i++ ) { skin = tr.skins[i]; ri.Printf( PRINT_ALL, "%3i:%s\n", i, skin->name ); for ( j = 0 ; j < skin->numSurfaces ; j++ ) { ri.Printf( PRINT_ALL, " %s = %s\n", skin->surfaces[j]->name, skin->surfaces[j]->shader->name ); } } ri.Printf (PRINT_ALL, "------------------\n"); }