648 lines
19 KiB
C++
Executable File
648 lines
19 KiB
C++
Executable File
/***************************************************************************
|
|
* Copyright (C) 2001-2023 by Tom Hicks *
|
|
* headhunter3@gmail.com *
|
|
* *
|
|
* This program 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. *
|
|
* *
|
|
* This program 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 this program; if not, write to the *
|
|
* Free Software Foundation, Inc., *
|
|
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
|
|
***************************************************************************/
|
|
#include "tga.h"
|
|
|
|
#include <OpenGL/gl.h>
|
|
|
|
#ifdef WIN32
|
|
#pragma warning(disable : 4996)
|
|
#endif
|
|
|
|
namespace OpenArena {
|
|
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 = (uint8_t*)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 (uint32_t 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 = (uint8_t*)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;
|
|
}
|
|
|
|
uint32_t pixelcount = tga.Height * tga.Width;
|
|
uint32_t currentpixel = 0;
|
|
uint32_t currentbyte = 0;
|
|
uint8_t* colorbuffer = (uint8_t*)malloc(tga.bytesPerPixel);
|
|
|
|
do {
|
|
uint8_t chunkheader = 0;
|
|
|
|
if (fread(&chunkheader, sizeof(uint8_t), 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 = (uint8_t *)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(uint32_t 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 = (uint8_t *)malloc(tga.imageSize);
|
|
|
|
if(image->data == NULL)
|
|
{
|
|
MessageBox(NULL, "Could not allocate memory for image", "ERROR",
|
|
MB_OK); fclose(fTGA); return NULL;
|
|
}
|
|
|
|
uint32_t pixelcount = tga.Height * tga.Width;
|
|
uint32_t currentpixel = 0;
|
|
uint32_t currentbyte = 0;
|
|
uint8_t * colorbuffer = (uint8_t *)malloc(tga.bytesPerPixel);
|
|
|
|
do
|
|
{
|
|
uint8_t chunkheader = 0;
|
|
|
|
if(fread(&chunkheader, sizeof(uint8_t), 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;
|
|
}
|
|
*/
|
|
} // End namespace OpenArena
|