665 lines
13 KiB
C++
665 lines
13 KiB
C++
|
|
#include "../include/tga.h"
|
|
|
|
TextureImage* LoadTGA(const char * filename)
|
|
{
|
|
TGAHeader tgaheader;
|
|
TextureImage* image;
|
|
std::string errmsg;
|
|
FILE* file = fopen(filename, "rb");
|
|
|
|
if(file == NULL)
|
|
{
|
|
errmsg = "Could not open texture file ";
|
|
errmsg = errmsg + filename;
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, errmsg.c_str(), "ERROR", MB_OK);
|
|
#endif
|
|
return NULL;
|
|
}
|
|
|
|
if(fread(&tgaheader, sizeof(TGAHeader), 1, file) == 0)
|
|
{
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, "Could not read file header", "ERROR", MB_OK);
|
|
#endif
|
|
if(file != NULL)
|
|
fclose(file);
|
|
return NULL;
|
|
}
|
|
|
|
if(memcmp(uTGAcompare, &tgaheader, sizeof(tgaheader)) == 0)
|
|
image = LoadUncompressedTGA(file);
|
|
else if(memcmp(cTGAcompare, &tgaheader, sizeof(tgaheader)) == 0)
|
|
image = LoadCompressedTGA(file);
|
|
else
|
|
{
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, "TGA file must be type 2 or type 10 ", "Invalid Image", MB_OK);
|
|
#endif
|
|
fclose(file);
|
|
return NULL;
|
|
}
|
|
return image;
|
|
}
|
|
|
|
TextureImage* LoadUncompressedTGA(FILE * fTGA)
|
|
{
|
|
TGA tga;
|
|
TextureImage* image = new TextureImage;
|
|
|
|
if(fread(tga.header, sizeof(tga.header), 1, fTGA) == 0)
|
|
{
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, "Could not read info header", "ERROR", MB_OK);
|
|
#endif
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
image->sizeY = tga.header[1] * 256 + tga.header[0];
|
|
image->sizeX = tga.header[3] * 256 + tga.header[2];
|
|
image->bpp = tga.header[4];
|
|
tga.Width = image->sizeX;
|
|
tga.Height = image->sizeY;
|
|
tga.Bpp = image->bpp;
|
|
|
|
if((image->sizeX <= 0) || (image->sizeY <= 0) || ((image->bpp != 24) && (image->bpp !=32)))
|
|
{
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, "Invalid texture information", "ERROR", MB_OK);
|
|
#endif
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
if(image->bpp == 24)
|
|
{
|
|
image->type = GL_RGB;
|
|
}
|
|
else
|
|
{
|
|
image->type = GL_RGBA;
|
|
}
|
|
|
|
tga.bytesPerPixel = (tga.Bpp / 8);
|
|
tga.imageSize = (tga.bytesPerPixel * tga.Width * tga.Height);
|
|
image->data = (GLubyte *)malloc(tga.imageSize);
|
|
|
|
if(image->data == NULL)
|
|
{
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, "Could not allocate memory for image", "ERROR", MB_OK);
|
|
#endif
|
|
fclose(fTGA);
|
|
return NULL;
|
|
}
|
|
|
|
if(fread(image->data, 1, tga.imageSize, fTGA) != tga.imageSize)
|
|
{
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, "Could not read image data", "ERROR", MB_OK);
|
|
#endif
|
|
if(image->data != NULL)
|
|
{
|
|
free(image->data);
|
|
}
|
|
fclose(fTGA);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
for(GLuint cswap = 0; cswap < (int)tga.imageSize; cswap += tga.bytesPerPixel)
|
|
{
|
|
image->data[cswap] ^= image->data[cswap+2] ^=
|
|
image->data[cswap] ^= image->data[cswap+2];
|
|
}
|
|
|
|
fclose(fTGA);
|
|
return image;
|
|
}
|
|
|
|
TextureImage* LoadCompressedTGA(FILE * fTGA)
|
|
{
|
|
TextureImage* image = new TextureImage;
|
|
TGA tga;
|
|
|
|
if(fread(tga.header, sizeof(tga.header), 1, fTGA) == 0)
|
|
{
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, "Could not read info header", "ERROR", MB_OK);
|
|
#endif
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
image->sizeX = tga.header[1] * 256 + tga.header[0];
|
|
image->sizeY = tga.header[3] * 256 + tga.header[2];
|
|
image->bpp = tga.header[4];
|
|
tga.Width = image->sizeX;
|
|
tga.Height = image->sizeY;
|
|
tga.Bpp = image->bpp;
|
|
|
|
if((image->sizeX <= 0) || (image->sizeY <= 0) || ((image->bpp != 24) && (image->bpp !=32)))
|
|
{
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, "Invalid texture information", "ERROR", MB_OK);
|
|
#endif
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
tga.bytesPerPixel = (tga.Bpp / 8);
|
|
tga.imageSize = (tga.bytesPerPixel * tga.Width * tga.Height);
|
|
image->data = (GLubyte *)malloc(tga.imageSize);
|
|
|
|
if(image->data == NULL)
|
|
{
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, "Could not allocate memory for image", "ERROR", MB_OK);
|
|
#endif
|
|
fclose(fTGA);
|
|
return NULL;
|
|
}
|
|
|
|
GLuint pixelcount = tga.Height * tga.Width;
|
|
GLuint currentpixel = 0;
|
|
GLuint currentbyte = 0;
|
|
GLubyte * colorbuffer = (GLubyte *)malloc(tga.bytesPerPixel);
|
|
|
|
do
|
|
{
|
|
GLubyte chunkheader = 0;
|
|
|
|
if(fread(&chunkheader, sizeof(GLubyte), 1, fTGA) == 0)
|
|
{
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, "Could not read RLE header", "ERROR", MB_OK);
|
|
#endif
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
if(image->data != NULL)
|
|
{
|
|
free(image->data);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
if(chunkheader < 128)
|
|
{
|
|
chunkheader++;
|
|
for(short counter = 0; counter < chunkheader; counter++)
|
|
{
|
|
if(fread(colorbuffer, 1, tga.bytesPerPixel, fTGA) != tga.bytesPerPixel)
|
|
{
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, "Could not read image data", "ERROR", MB_OK);
|
|
#endif
|
|
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
|
|
if(colorbuffer != NULL)
|
|
{
|
|
free(colorbuffer);
|
|
}
|
|
|
|
if(image->data != NULL)
|
|
{
|
|
free(image->data);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
image->data[currentbyte ] = colorbuffer[2];
|
|
image->data[currentbyte + 1 ] = colorbuffer[1];
|
|
image->data[currentbyte + 2 ] = colorbuffer[0];
|
|
|
|
if(tga.bytesPerPixel == 4)
|
|
{
|
|
image->data[currentbyte + 3] = colorbuffer[3];
|
|
}
|
|
|
|
currentbyte += tga.bytesPerPixel;
|
|
currentpixel++;
|
|
|
|
if(currentpixel > pixelcount)
|
|
{
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, "Too many pixels read", "ERROR", NULL);
|
|
#endif
|
|
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
|
|
if(colorbuffer != NULL)
|
|
{
|
|
free(colorbuffer);
|
|
}
|
|
|
|
if(image->data != NULL)
|
|
{
|
|
free(image->data);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
chunkheader -= 127;
|
|
if(fread(colorbuffer, 1, tga.bytesPerPixel, fTGA) != tga.bytesPerPixel)
|
|
{
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, "Could not read from file", "ERROR", MB_OK);
|
|
#endif
|
|
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
|
|
if(colorbuffer != NULL)
|
|
{
|
|
free(colorbuffer);
|
|
}
|
|
|
|
if(image->data != NULL)
|
|
{
|
|
free(image->data);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
for(short counter = 0; counter < chunkheader; counter++)
|
|
{
|
|
image->data[currentbyte ] = colorbuffer[2];
|
|
image->data[currentbyte + 1 ] = colorbuffer[1];
|
|
image->data[currentbyte + 2 ] = colorbuffer[0];
|
|
|
|
if(tga.bytesPerPixel == 4)
|
|
{
|
|
image->data[currentbyte + 3] = colorbuffer[3];
|
|
}
|
|
|
|
currentbyte += tga.bytesPerPixel;
|
|
currentpixel++;
|
|
|
|
if(currentpixel > pixelcount)
|
|
{
|
|
//This needs to be abstracted somehow
|
|
#ifdef WIN32
|
|
MessageBox(NULL, "Too many pixels read", "ERROR", NULL);
|
|
#endif
|
|
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
|
|
if(colorbuffer != NULL)
|
|
{
|
|
free(colorbuffer);
|
|
}
|
|
|
|
if(image->data != NULL)
|
|
{
|
|
free(image->data);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
while(currentpixel < pixelcount);
|
|
fclose(fTGA);
|
|
return image;
|
|
}
|
|
|
|
|
|
/*
|
|
TextureImage* LoadTGA(const char * filename)
|
|
{
|
|
TGAHeader tgaheader;
|
|
TextureImage* image;
|
|
std::string errmsg;
|
|
FILE* file = fopen(filename, "rb");
|
|
|
|
if(file == NULL)
|
|
{
|
|
errmsg = "Could not open texture file ";
|
|
errmsg = errmsg + filename;
|
|
MessageBox(NULL, errmsg.c_str(), "ERROR", MB_OK);
|
|
return NULL;
|
|
}
|
|
|
|
if(fread(&tgaheader, sizeof(TGAHeader), 1, file) == 0)
|
|
{
|
|
MessageBox(NULL, "Could not read file header", "ERROR", MB_OK);
|
|
if(file != NULL)
|
|
fclose(file);
|
|
return NULL;
|
|
}
|
|
|
|
if(memcmp(uTGAcompare, &tgaheader, sizeof(tgaheader)) == 0)
|
|
image = LoadUncompressedTGA(file);
|
|
else if(memcmp(cTGAcompare, &tgaheader, sizeof(tgaheader)) == 0)
|
|
image = LoadCompressedTGA(file);
|
|
else
|
|
{
|
|
MessageBox(NULL, "TGA file must be type 2 or type 10 ", "Invalid Image", MB_OK);
|
|
fclose(file);
|
|
return NULL;
|
|
}
|
|
return image;
|
|
}
|
|
|
|
TextureImage* LoadUncompressedTGA(FILE * fTGA)
|
|
{
|
|
TGA tga;
|
|
TextureImage* image = new TextureImage;
|
|
|
|
if(fread(tga.header, sizeof(tga.header), 1, fTGA) == 0)
|
|
{
|
|
MessageBox(NULL, "Could not read info header", "ERROR", MB_OK);
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
image->sizeY = tga.header[1] * 256 + tga.header[0];
|
|
image->sizeX = tga.header[3] * 256 + tga.header[2];
|
|
image->bpp = tga.header[4];
|
|
tga.Width = image->sizeX;
|
|
tga.Height = image->sizeY;
|
|
tga.Bpp = image->bpp;
|
|
|
|
if((image->sizeX <= 0) || (image->sizeY <= 0) || ((image->bpp != 24) && (image->bpp !=32)))
|
|
{
|
|
MessageBox(NULL, "Invalid texture information", "ERROR", MB_OK);
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
if(image->bpp == 24)
|
|
{
|
|
image->type = GL_RGB;
|
|
}
|
|
else
|
|
{
|
|
image->type = GL_RGBA;
|
|
}
|
|
|
|
tga.bytesPerPixel = (tga.Bpp / 8);
|
|
tga.imageSize = (tga.bytesPerPixel * tga.Width * tga.Height);
|
|
image->data = (GLubyte *)malloc(tga.imageSize);
|
|
|
|
if(image->data == NULL)
|
|
{
|
|
MessageBox(NULL, "Could not allocate memory for image", "ERROR", MB_OK);
|
|
fclose(fTGA);
|
|
return NULL;
|
|
}
|
|
|
|
if(fread(image->data, 1, tga.imageSize, fTGA) != tga.imageSize)
|
|
{
|
|
MessageBox(NULL, "Could not read image data", "ERROR", MB_OK);
|
|
if(image->data != NULL)
|
|
{
|
|
free(image->data);
|
|
}
|
|
fclose(fTGA);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
for(GLuint cswap = 0; cswap < (int)tga.imageSize; cswap += tga.bytesPerPixel)
|
|
{
|
|
image->data[cswap] ^= image->data[cswap+2] ^=
|
|
image->data[cswap] ^= image->data[cswap+2];
|
|
}
|
|
|
|
fclose(fTGA);
|
|
return image;
|
|
}
|
|
|
|
TextureImage* LoadCompressedTGA(FILE * fTGA)
|
|
{
|
|
TextureImage* image = new TextureImage;
|
|
TGA tga;
|
|
|
|
if(fread(tga.header, sizeof(tga.header), 1, fTGA) == 0)
|
|
{
|
|
MessageBox(NULL, "Could not read info header", "ERROR", MB_OK);
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
image->sizeX = tga.header[1] * 256 + tga.header[0];
|
|
image->sizeY = tga.header[3] * 256 + tga.header[2];
|
|
image->bpp = tga.header[4];
|
|
tga.Width = image->sizeX;
|
|
tga.Height = image->sizeY;
|
|
tga.Bpp = image->bpp;
|
|
|
|
if((image->sizeX <= 0) || (image->sizeY <= 0) || ((image->bpp != 24) && (image->bpp !=32)))
|
|
{
|
|
MessageBox(NULL, "Invalid texture information", "ERROR", MB_OK);
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
tga.bytesPerPixel = (tga.Bpp / 8);
|
|
tga.imageSize = (tga.bytesPerPixel * tga.Width * tga.Height);
|
|
image->data = (GLubyte *)malloc(tga.imageSize);
|
|
|
|
if(image->data == NULL)
|
|
{
|
|
MessageBox(NULL, "Could not allocate memory for image", "ERROR", MB_OK);
|
|
fclose(fTGA);
|
|
return NULL;
|
|
}
|
|
|
|
GLuint pixelcount = tga.Height * tga.Width;
|
|
GLuint currentpixel = 0;
|
|
GLuint currentbyte = 0;
|
|
GLubyte * colorbuffer = (GLubyte *)malloc(tga.bytesPerPixel);
|
|
|
|
do
|
|
{
|
|
GLubyte chunkheader = 0;
|
|
|
|
if(fread(&chunkheader, sizeof(GLubyte), 1, fTGA) == 0)
|
|
{
|
|
MessageBox(NULL, "Could not read RLE header", "ERROR", MB_OK);
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
if(image->data != NULL)
|
|
{
|
|
free(image->data);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
if(chunkheader < 128)
|
|
{
|
|
chunkheader++;
|
|
for(short counter = 0; counter < chunkheader; counter++)
|
|
{
|
|
if(fread(colorbuffer, 1, tga.bytesPerPixel, fTGA) != tga.bytesPerPixel)
|
|
{
|
|
MessageBox(NULL, "Could not read image data", "ERROR", MB_OK);
|
|
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
|
|
if(colorbuffer != NULL)
|
|
{
|
|
free(colorbuffer);
|
|
}
|
|
|
|
if(image->data != NULL)
|
|
{
|
|
free(image->data);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
image->data[currentbyte ] = colorbuffer[2];
|
|
image->data[currentbyte + 1 ] = colorbuffer[1];
|
|
image->data[currentbyte + 2 ] = colorbuffer[0];
|
|
|
|
if(tga.bytesPerPixel == 4)
|
|
{
|
|
image->data[currentbyte + 3] = colorbuffer[3];
|
|
}
|
|
|
|
currentbyte += tga.bytesPerPixel;
|
|
currentpixel++;
|
|
|
|
if(currentpixel > pixelcount)
|
|
{
|
|
MessageBox(NULL, "Too many pixels read", "ERROR", NULL);
|
|
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
|
|
if(colorbuffer != NULL)
|
|
{
|
|
free(colorbuffer);
|
|
}
|
|
|
|
if(image->data != NULL)
|
|
{
|
|
free(image->data);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
chunkheader -= 127;
|
|
if(fread(colorbuffer, 1, tga.bytesPerPixel, fTGA) != tga.bytesPerPixel)
|
|
{
|
|
MessageBox(NULL, "Could not read from file", "ERROR", MB_OK);
|
|
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
|
|
if(colorbuffer != NULL)
|
|
{
|
|
free(colorbuffer);
|
|
}
|
|
|
|
if(image->data != NULL)
|
|
{
|
|
free(image->data);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
for(short counter = 0; counter < chunkheader; counter++)
|
|
{
|
|
image->data[currentbyte ] = colorbuffer[2];
|
|
image->data[currentbyte + 1 ] = colorbuffer[1];
|
|
image->data[currentbyte + 2 ] = colorbuffer[0];
|
|
|
|
if(tga.bytesPerPixel == 4)
|
|
{
|
|
image->data[currentbyte + 3] = colorbuffer[3];
|
|
}
|
|
|
|
currentbyte += tga.bytesPerPixel;
|
|
currentpixel++;
|
|
|
|
if(currentpixel > pixelcount)
|
|
{
|
|
MessageBox(NULL, "Too many pixels read", "ERROR", NULL);
|
|
|
|
if(fTGA != NULL)
|
|
{
|
|
fclose(fTGA);
|
|
}
|
|
|
|
if(colorbuffer != NULL)
|
|
{
|
|
free(colorbuffer);
|
|
}
|
|
|
|
if(image->data != NULL)
|
|
{
|
|
free(image->data);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
while(currentpixel < pixelcount);
|
|
fclose(fTGA);
|
|
return image;
|
|
}
|
|
*/
|