@@ -49,7 +49,7 @@ bool LoadTGATextureData(const char *filename, TextureData *texture)	// Loads A T

 	GLubyte *rowP;

 	int err;

 	GLubyte rle;

-	int b;

+	GLuint b;

 	long row, rowLimit;

 	GLubyte pixelData[4];	

@@ -199,7 +199,7 @@ bool LoadTGATextureData(const char *filename, TextureData *texture)	// Loads A T

 	}

 	if (bytesPerPixel >= 3) // if not monochrome	

-	for (i = 0; i < (int)(imageSize); i += bytesPerPixel)	// Loop Through The Image Data

+	for (i = 0; i < imageSize; i += bytesPerPixel)	// Loop Through The Image Data

 	{		// Swaps The 1st And 3rd Bytes ('R'ed and 'B'lue)

 		temp = texture->imageData[i];		// Temporarily Store The Value At Image Data 'i'

 		texture->imageData[i] = texture->imageData[i + 2];	// Set The 1st Byte To The Value Of The 3rd Byte

@@ -53,7 +53,7 @@ bool LoadTGATextureData(const char *filename, TextureData *texture)	// Loads A T

 	long row, rowLimit;

 	GLubyte pixelData[4];	

-	// Nytt f�r flipping-st�d 111114

+	// Nytt för flipping-stöd 111114

 	char flipped;

 	long step;

old mode 100755

new mode 100644

@@ -12,6 +12,8 @@

 // 180216: calloc is better than malloc when you may have undefined data in parts of the texture!

 // 190416: Skipped testing the last four bytes of the 12-byte heading. That is the origin of the

 // image which is usually 0. It is now ignored.

+// 220218: Big change: Removed the power of 2. GPUs with that limitation are gone now.

+// This simplifies both the code and the interface.

 // NOTE: LoadTGA does NOT support all TGA variants! You may need to re-save your TGA

 // with different settings to find a suitable format.

@@ -43,7 +45,7 @@ bool LoadTGATextureData(const char *filename, TextureData *texture)	// Loads A T

 		imageSize,		// Used To Store The Image Size When Setting Aside Ram

 		temp;			// Temporary Variable

 	long rowSize, stepSize, bytesRead;

-	long w, h;

+//	long w, h;

 	GLubyte *rowP;

 	int err;

 	GLubyte rle;

@@ -109,20 +111,21 @@ bool LoadTGATextureData(const char *filename, TextureData *texture)	// Loads A T

 		return false;

 	}

 	flipped = (header[5] & 32) != 0; // Testa om flipped

-	

-	w = 1;

-	while (w < texture->width) w = w << 1;

-	h = 1;

-	while (h < texture->height) h = h << 1;

-	texture->texWidth = (GLfloat)texture->width / w;

-	texture->texHeight = (GLfloat)texture->height / h;

+

+// That old power of 2 is no longer needed!

+//	w = 1;

+//	while (w < texture->width) w = w << 1;

+//	h = 1;

+//	while (h < texture->height) h = h << 1;

+//	texture->texWidth = (GLfloat)texture->width / w;

+//	texture->texHeight = (GLfloat)texture->height / h;

 	texture->bpp = header[4];		// Grab The TGA's Bits Per Pixel (24 or 32)

 	bytesPerPixel = texture->bpp/8;		// Divide By 8 To Get The Bytes Per Pixel

-	imageSize = w * h * bytesPerPixel;	// Calculate The Memory Required For The TGA Data

+	imageSize = texture->width * texture->height * bytesPerPixel;	// Calculate The Memory Required For The TGA Data

 	rowSize	= texture->width * bytesPerPixel;	// Image memory per row

-	stepSize = w * bytesPerPixel;		// Memory per row

+	stepSize = texture->width * bytesPerPixel;		// Memory per row

 	texture->imageData = (GLubyte *)calloc(1, imageSize);	// Reserve Memory To Hold The TGA Data

 	if (texture->imageData == NULL)				// Does The Storage Memory Exist?

 	{

@@ -133,7 +136,7 @@ bool LoadTGATextureData(const char *filename, TextureData *texture)	// Loads A T

 	// Set rowP and step depending on direction

 	// Inverted this 120131, since a texture came out wrong.

 	// I am still not sure this is OK.

-	if (!flipped)

+	if (flipped)

 	{

 		step = -stepSize;

 		rowP = &texture->imageData[imageSize - stepSize];

@@ -204,8 +207,8 @@ bool LoadTGATextureData(const char *filename, TextureData *texture)	// Loads A T

 	}

 	fclose (file);

-texture->w = w;

-texture->h = h;

+//texture->w = w;

+//texture->h = h;

 	return true;				// Texture loading Went Ok, Return True

 }

@@ -232,7 +235,7 @@ bool LoadTGATexture(const char *filename, TextureData *texture)	// Loads A TGA F

 	{

 		type=GL_RGB;			// If So Set The 'type' To GL_RGB

 	}

-	glTexImage2D(GL_TEXTURE_2D, 0, type, texture->w, texture->h, 0, type, GL_UNSIGNED_BYTE, texture[0].imageData);

+	glTexImage2D(GL_TEXTURE_2D, 0, type, texture->width, texture->height, 0, type, GL_UNSIGNED_BYTE, texture[0].imageData);

 	if (gMipmap)

 	{

@@ -324,7 +327,8 @@ int SaveDataToTGA(char			*filename,

 	fclose(file);

 // release the memory

-	free(imageData);

+// No, this is the responsability of the host!

+//	free(imageData);

 	return(TGA_OK);

 }

new file mode 100755

@@ -0,0 +1,351 @@

+// TGA loader, by Ingemar 2009, based on "tga.c" and some other sources.

+// Updated 2013 to use modern mipmapping

+// 130423: Added LoadTGATextureData

+// 130905: Fixed a bug in LoadTGATextureSimple

+// 140212: Fixed a bug in loading of uncompressed images.

+// 140520: Supports grayscale images (loads to red channel).

+// 141007: Added SaveTGA. (Moved from the obsolete LoadTGA2.)

+// 160302: Uses fopen_s on Windows, as suggested by Jesper Post. Should reduce warnings a bit.

+// 170220: Changed fopen_s to "rb". This made it fail for some textures.

+// 170331: Cleaned up a bit to remove warnings.

+// 170419: Fixed a bug that prevented monochrome images from loading.

+// 180216: calloc is better than malloc when you may have undefined data in parts of the texture!

+// 190416: Skipped testing the last four bytes of the 12-byte heading. That is the origin of the

+// image which is usually 0. It is now ignored.

+

+// NOTE: LoadTGA does NOT support all TGA variants! You may need to re-save your TGA

+// with different settings to find a suitable format.

+

+#include "LoadTGA.h"

+

+static bool gMipmap = true;

+

+// Note that turning mimpapping on and off refers to the loading stage only.

+// If you want to turn off mipmapping later, use 

+// glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

+

+void LoadTGASetMipmapping(bool active)

+{

+	gMipmap = active;

+}

+

+bool LoadTGATextureData(const char *filename, TextureData *texture)	// Loads A TGA File Into Memory

+{

+	GLuint i;

+	GLubyte

+		TGAuncompressedheader[12]={ 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0},	// Uncompressed TGA Header

+		TGAcompressedheader[12]={ 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0},	// Compressed TGA Header

+		TGAuncompressedbwheader[12]={ 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0},	// Uncompressed grayscale TGA Header

+		TGAcompressedbwheader[12]={ 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0},	// Compressed grayscale TGA Header

+		actualHeader[12],	// Used To Compare TGA Header

+		header[6];		// First 6 Useful Bytes From The Header

+	GLuint bytesPerPixel,		// Holds Number Of Bytes Per Pixel Used In The TGA File

+		imageSize,		// Used To Store The Image Size When Setting Aside Ram

+		temp;			// Temporary Variable

+	long rowSize, stepSize, bytesRead;

+	long w, h;

+	GLubyte *rowP;

+	int err;

+	GLubyte rle;

+	int b;

+	long row, rowLimit;

+	GLubyte pixelData[4];	

+	

+	// Nytt f�r flipping-st�d 111114

+	char flipped;

+	long step;

+	

+	// It seems Windows/VS doesn't like fopen any more, but fopen_s is not on the others.

+	FILE *file;

+	#if defined(_WIN32)

+		fopen_s(&file, filename, "rb");

+	#else

+		file = fopen(filename, "rb"); // rw works everywhere except Windows?

+	#endif

+//	FILE *file = fopen(filename, "rb");			// Open The TGA File

+	err = 0;

+	if (file == NULL) err = 1;				// Does File Even Exist?

+	else if (fread(actualHeader, 1, sizeof(actualHeader), file) != sizeof(actualHeader)) err = 2; // Are There 12 Bytes To Read?

+	else if (

+	// Edit 2019: Ignore the origin!

+				(memcmp(TGAuncompressedheader, actualHeader, sizeof(TGAuncompressedheader)-4) != 0) &&

+				(memcmp(TGAcompressedheader, actualHeader, sizeof(TGAcompressedheader)-4) != 0) &&

+				(memcmp(TGAuncompressedbwheader, actualHeader, sizeof(TGAuncompressedheader)-4) != 0) &&

+				(memcmp(TGAcompressedbwheader, actualHeader, sizeof(TGAcompressedheader)-4) != 0)

+			)

+			{

+				err = 3; // Does The Header Match What We Want?

+				for (i = 0; i < 12; i++)

+					printf("%d ", actualHeader[i]);

+				printf("\n");

+			}

+	else if (fread(header, 1, sizeof(header), file) != sizeof(header)) err = 4; // If So Read Next 6 Header Bytes

+	

+	if (err != 0)

+	{

+		switch (err)

+		{

+			case 1: printf("could not open file %s\n", filename); break;

+			case 2: printf("could not read header of %s\n", filename); break;

+			case 3: printf("unsupported format in %s\n", filename); break;

+			case 4: printf("could not read file %s\n", filename); break;

+		}

+		

+		if(file == NULL)		// Did The File Even Exist? *Added Jim Strong*

+			return false;

+		else

+		{

+			fclose(file);		// If Anything Failed, Close The File

+			return false;

+		}

+	}

+	texture->width  = header[1] * 256 + header[0];	// Determine The TGA Width (highbyte*256+lowbyte)

+	texture->height = header[3] * 256 + header[2];	// Determine The TGA Height (highbyte*256+lowbyte)

+	if (texture->width <= 0 ||	// Is The Width Less Than Or Equal To Zero

+	texture->height <= 0 ||		// Is The Height Less Than Or Equal To Zero

+	(header[4] != 24 && header[4] != 32 && header[4] != 8))			// Is The TGA 24 or 32 Bit?

+	{

+		fclose(file);		// If Anything Failed, Close The File

+		return false;

+	}

+	flipped = (header[5] & 32) != 0; // Testa om flipped

+	

+	w = 1;

+	while (w < texture->width) w = w << 1;

+	h = 1;

+	while (h < texture->height) h = h << 1;

+	texture->texWidth = (GLfloat)texture->width / w;

+	texture->texHeight = (GLfloat)texture->height / h;

+	

+	

+	texture->bpp = header[4];		// Grab The TGA's Bits Per Pixel (24 or 32)

+	bytesPerPixel = texture->bpp/8;		// Divide By 8 To Get The Bytes Per Pixel

+	imageSize = w * h * bytesPerPixel;	// Calculate The Memory Required For The TGA Data

+	rowSize	= texture->width * bytesPerPixel;	// Image memory per row

+	stepSize = w * bytesPerPixel;		// Memory per row

+	texture->imageData = (GLubyte *)calloc(1, imageSize);	// Reserve Memory To Hold The TGA Data

+	if (texture->imageData == NULL)				// Does The Storage Memory Exist?

+	{

+		fclose(file);

+		return false;

+	}

+

+	// Set rowP and step depending on direction

+	// Inverted this 120131, since a texture came out wrong.

+	// I am still not sure this is OK.

+	if (!flipped)

+	{

+		step = -stepSize;

+		rowP = &texture->imageData[imageSize - stepSize];

+		row = 0 + (texture->height -1) * stepSize;

+	}

+	else

+	{

+		step = stepSize;

+		rowP = &texture->imageData[0];

+		row = 0;

+	}

+

+	if (actualHeader[2] == 2 || actualHeader[2] == 3) // uncompressed

+	{

+		for (i = 0; i < texture->height; i++)

+		{

+			bytesRead = fread(rowP, 1, rowSize, file);

+			rowP += step;

+			if (bytesRead != rowSize)

+			{

+				free(texture->imageData);	// If So, Release The Image Data

+				fclose(file);			// Close The File

+				return false;			// Return False

+			}

+		}

+	}

+	else

+	{ // compressed

+//		row = 0 + (texture->height -1) * stepSize;

+		i = row;

+		rowLimit = row + rowSize;

+		do

+		{

+			bytesRead = fread(&rle, 1, 1, file);

+			if (rle < 128)

+			{ // rle+1 raw pixels

+				bytesRead = fread(&texture->imageData[i], 1, (rle+1)*bytesPerPixel, file);

+				i += bytesRead;

+				if (bytesRead == 0)

+					i = imageSize;

+			}

+			else

+			{ // range of rle-127 pixels with a color that follows

+				bytesRead = fread(&pixelData, 1, bytesPerPixel, file);

+				do

+				{

+					for (b = 0; b < bytesPerPixel; b++)

+						texture->imageData[i+b] = pixelData[b];

+					i += bytesPerPixel;

+					rle = rle - 1;

+				} while (rle > 127);

+			}

+			if (i >= rowLimit)

+			{

+				row = row + step; // - stepSize;

+				rowLimit = row + rowSize;

+				i = row;

+			}

+		} while (i < imageSize);

+	}

+

+	if (bytesPerPixel >= 3) // if not monochrome	

+	for (i = 0; i < (int)(imageSize); i += bytesPerPixel)	// Loop Through The Image Data

+	{		// Swaps The 1st And 3rd Bytes ('R'ed and 'B'lue)

+		temp = texture->imageData[i];		// Temporarily Store The Value At Image Data 'i'

+		texture->imageData[i] = texture->imageData[i + 2];	// Set The 1st Byte To The Value Of The 3rd Byte

+		texture->imageData[i + 2] = temp;	// Set The 3rd Byte To The Value In 'temp' (1st Byte Value)

+	}

+	fclose (file);

+

+texture->w = w;

+texture->h = h;

+

+	return true;				// Texture loading Went Ok, Return True

+}

+

+bool LoadTGATexture(const char *filename, TextureData *texture)	// Loads A TGA File Into Memory and creates texture object

+{

+	char ok;

+	GLuint type = GL_RGBA;		// Set The Default GL Mode To RBGA (32 BPP)

+	

+	ok = LoadTGATextureData(filename, texture);	// Loads A TGA File Into Memory

+	if (!ok)

+		return false;

+

+	// Build A Texture From The Data

+	glGenTextures(1, &texture->texID);			// Generate OpenGL texture IDs

+	glBindTexture(GL_TEXTURE_2D, texture->texID);		// Bind Our Texture

+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);	// Linear Filtered

+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);	// Linear Filtered

+	if (texture->bpp == 8)						// Was The TGA 8 Bits? Should be grayscale then.

+	{

+		type=GL_RED;			// If So Set The 'type' To GL_RED

+	}

+	if (texture->bpp == 24)						// Was The TGA 24 Bits?

+	{

+		type=GL_RGB;			// If So Set The 'type' To GL_RGB

+	}

+	glTexImage2D(GL_TEXTURE_2D, 0, type, texture->w, texture->h, 0, type, GL_UNSIGNED_BYTE, texture[0].imageData);

+	

+	if (gMipmap)

+	{

+		glGenerateMipmap(GL_TEXTURE_2D);

+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);	// Linear Filtered

+	}

+	

+	return true;				// Texture Building Went Ok, Return True

+}

+

+void LoadTGATextureSimple(const char *filename, GLuint *tex) // If you really only need the texture object.

+{

+	TextureData texture;

+	memset(&texture, 0, sizeof(texture)); // Bug fix 130905.

+	

+	if (LoadTGATexture(filename, &texture))

+	{

+		if(texture.imageData != NULL)

+			free(texture.imageData);

+		*tex = texture.texID;

+	}

+	else

+		*tex = 0;

+}

+

+

+// saves an array of pixels as a TGA image

+// Was tgaSave, found in some reusable code.

+// Limitation: Can NOT save with transparency! Only RGB, not RGBA!

+// But it should! Why not?

+int SaveDataToTGA(char			*filename, 

+			 short int		width, 

+			 short int		height, 

+			 unsigned char	pixelDepth,

+			 unsigned char	*imageData)

+{

+	unsigned char cGarbage = 0, mode,aux;

+	int i, w, ix;

+	FILE *file;

+	char /*GLubyte*/ TGAuncompressedheader[12]={ 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0};	// Uncompressed TGA Header

+

+// open file and check for errors

+#if defined(_WIN32)

+	fopen_s(&file, filename, "w");

+#else

+	file = fopen(filename, "w"); // rw works everywhere except Windows?

+#endif

+//	file = fopen(filename, "w");

+	if (file == NULL)

+		return(TGA_ERROR_FILE_OPEN);

+

+// compute image type: 2 for RGB(A), 3 for greyscale

+	mode = pixelDepth / 8;

+// NOT YET IMPLEMENTED

+//	if ((pixelDepth == 24) || (pixelDepth == 32))

+//		type = 2;

+//	else

+//		type = 3;

+

+// write the header

+	fwrite(&TGAuncompressedheader, 12, 1, file);

+	fwrite(&width, sizeof(short int), 1, file);

+	fwrite(&height, sizeof(short int), 1, file);

+	fwrite(&pixelDepth, sizeof(unsigned char), 1, file);

+

+	fwrite(&cGarbage, sizeof(unsigned char), 1, file);

+

+// convert the image data from RGB(a) to BGR(A)

+	if (mode >= 3)

+	for (i=0; i < width * height * mode ; i+= mode)

+	{

+		aux = imageData[i];

+		imageData[i] = imageData[i+2];

+		imageData[i+2] = aux;

+	}

+

+// save the image data

+	w = 1;

+	while (w < width) w = w << 1;

+//	bytesPerPixel = pixelDepth/8;	

+//	row = width * bytesPerPixel;

+	

+// Write one row at a time

+	for (i = 0; i < height; i++)

+	{

+		ix = i * w * mode;

+		fwrite(&imageData[ix], sizeof(unsigned char), width * mode, file);

+	}

+

+	fclose(file);

+// release the memory

+	free(imageData);

+

+	return(TGA_OK);

+}

+

+// Save a TextureData

+// Problem: Saves upside down!

+void SaveTGA(TextureData *tex, char *filename)

+{

+	SaveDataToTGA(filename, tex->width, tex->height, 

+			tex->bpp, tex->imageData);

+}

+

+void SaveFramebufferToTGA(char *filename, GLint x, GLint y, GLint w, GLint h)

+{

+	int err;

+	void *buffer = malloc(h*w*3);

+	glReadPixels(x, y, w, h, GL_RGB, GL_UNSIGNED_BYTE, buffer);

+	err = SaveDataToTGA(filename, w, h, 

+			3*8, (unsigned char *)buffer);

+//	free(buffer); already done

+	printf("SaveDataToTGA returned %d\n", err);

+}

+

+