#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <GL/gl.h>
class tgaImageFile
{
public:
tgaImageFile(void) :
m_texFormat(-1),
m_nImageWidth(0),
m_nImageHeight(0),
m_nImageBits(0),
m_nImageData(NULL) {}
~tgaImageFile(void);
enum TGALoadError
{
TGA_NO_ERROR = 1, // No error
TGA_FILE_NOT_FOUND, // File was not found
TGA_BAD_IMAGE_TYPE, // Color mapped image or image is not uncompressed
TGA_BAD_DIMENSION, // Dimension is not a power of 2
TGA_BAD_BITS, // Image bits is not 8, 24 or 32
TGA_BAD_DATA // Image data could not be loaded
};
tgaImageFile::TGALoadError load( char *name );
GLenum m_texFormat;
int m_nImageWidth;
int m_nImageHeight;
int m_nImageBits;
unsigned char * m_nImageData;
private:
bool checkSize(int x);
int returnError(FILE *s, int error);
unsigned char *getRGBA(FILE *s, int size);
unsigned char *getRGB(FILE *s, int size);
unsigned char *getGray(FILE *s, int size);
};
tgaImageFile::~tgaImageFile( void )
{
if( m_nImageData != NULL )
{
free( m_nImageData );
m_nImageData = NULL;
}
}
bool tgaImageFile::checkSize( int x )
{
/*
// Make sure its a power of 2.
if( x == 2 || x == 4 ||
x == 8 || x == 16 ||
x == 32 || x == 64 ||
x == 128 || x == 256 ||
x == 512 )
return true;
return false;
*/
return ( x & (x-1) == 0);
}
int tgaImageFile::returnError( FILE *s, int error )
{
// Called when there is an error loading the .tga texture file.
fclose( s );
return error;
}
unsigned char *tgaImageFile::getRGBA( FILE *s, int size )
{
// Read in RGBA data for a 32bit image.
unsigned char *rgba;
unsigned char temp;
int bread;
int i;
rgba = (unsigned char *)malloc( size * 4 );
if( rgba == NULL )
return 0;
bread = fread( rgba, sizeof (unsigned char), size * 4, s );
// TGA is stored in BGRA, make it RGBA
if( bread != size * 4 )
{
free( rgba );
return 0;
}
for( i = 0; i < size * 4; i += 4 )
{
temp = rgba[i];
rgba[i] = rgba[i + 2];
rgba[i + 2] = temp;
}
m_texFormat = GL_RGBA;
return rgba;
}
unsigned char *tgaImageFile::getRGB( FILE *s, int size )
{
// Read in RGB data for a 24bit image.
unsigned char *rgb;
unsigned char temp;
int bread;
int i;
rgb = (unsigned char*)malloc( size * 3 );
if( rgb == NULL )
return 0;
bread = fread( rgb, sizeof (unsigned char), size * 3, s );
if(bread != size * 3)
{
free( rgb );
return 0;
}
// TGA is stored in BGR, make it RGB
for( i = 0; i < size * 3; i += 3 )
{
temp = rgb[i];
rgb[i] = rgb[i + 2];
rgb[i + 2] = temp;
}
m_texFormat = GL_RGB;
return rgb;
}
unsigned char *tgaImageFile::getGray( FILE *s, int size )
{
// Gets the grayscale image data. Used as an alpha channel.
unsigned char *grayData;
int bread;
grayData = (unsigned char*)malloc( size );
if( grayData == NULL )
return 0;
bread = fread( grayData, sizeof (unsigned char), size, s );
if( bread != size )
{
free( grayData );
return 0;
}
m_texFormat = GL_ALPHA;
return grayData;
}
tgaImageFile::TGALoadError tgaImageFile::load( char *name )
{
// Loads up a targa file. Supported types are 8, 24 and 32
// uncompressed images.
unsigned char type[4];
unsigned char info[7];
FILE *s = NULL;
int size = 0;
if( !(s = fopen( name, "rb" )) )
return TGA_FILE_NOT_FOUND;
fread( &type, sizeof (char), 3, s ); // Read in colormap info and image type, byte 0 ignored
fseek( s, 12, SEEK_SET); // Seek past the header and useless info
fread( &info, sizeof (char), 6, s );
if( type[1] != 0 || (type[2] != 2 && type[2] != 3) )
returnError( s, TGA_BAD_IMAGE_TYPE );
m_nImageWidth = info[0] + info[1] * 256;
m_nImageHeight = info[2] + info[3] * 256;
m_nImageBits = info[4];
size = m_nImageWidth * m_nImageHeight;
// Make sure dimension is a power of 2
if( !checkSize(m_nImageWidth) || !checkSize(m_nImageHeight))
returnError( s, TGA_BAD_DIMENSION);
// Make sure we are loading a supported type
if( m_nImageBits != 32 && m_nImageBits != 24 && m_nImageBits != 8 )
returnError( s, TGA_BAD_BITS );
if( m_nImageBits == 32 )
m_nImageData = getRGBA( s, size );
else if( m_nImageBits == 24 )
m_nImageData = getRGB( s, size );
else if( m_nImageBits == 8 )
m_nImageData = getGray( s, size );
// No image data
if( m_nImageData == NULL )
returnError( s, TGA_BAD_DATA );
fclose( s );
return TGA_NO_ERROR;
}
调用举例:
//
// For the billboard poly, load a texture of a steel sphere. We'll use a
// .tga file for this image so we can use an alpha channel.
//
tgaImageFile tgaImage;
tgaImage.load( "steel_sphere.tga" );
glGenTextures( 1, &g_sphereTextureID );
glBindTexture( GL_TEXTURE_2D, g_sphereTextureID );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexImage2D( GL_TEXTURE_2D, 0, tgaImage.m_texFormat,
tgaImage.m_nImageWidth, tgaImage.m_nImageHeight,
0, tgaImage.m_texFormat, GL_UNSIGNED_BYTE,
tgaImage.m_nImageData );