maj/OpenArena
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reorganizes project and sets up bazel.

Browse Source
This commit is contained in:
Tom Hicks
2023-04-27 00:36:28 -07:00
parent 71ef1f41c5
commit 984631a216
454 changed files with 12818 additions and 111083 deletions
Download Patch File Download Diff File Expand all files Collapse all files

647
tga.cpp Executable file
View File

@@ -0,0 +1,647 @@
/***************************************************************************
* 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