/*************************************************************************
						Stereo pair image viewer by Aidan Crees

Usage: viewer leftimage.bmp rightimage.bmp [options]

Accepts 24bit bitmaps as arguments

Written by Aidan Crees, completed 6/2/04

-Draw text function from opengllib.c (by Paul Bourke)
-Bitmap loading function from http://nehe.gamedev.net, lesson 7
-TGA loading function from http://nehe.gamedev.net, lesson 33

Everything else written by Aidan Crees

Originally written under Linux, ported to Windows by changing TGA
function types from 'bool' to 'int', and returning 'true' to '1'
and 'false' to '0'.

Holds up to 20 images in memory.
*************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <GL/glut.h>
#include <GL/gl.h>
#include "Tga.h"

#define NOSTEREO 0
#define DUALSTEREO 1
#define ESC 27
#define SPACE 32
#define BITMAP 0
#define TARGA 1
#define LIST 3

GLenum fullscreen=0, info=0, cursor=0, screen=0, DisplayListContents=0,DisplayHelp=0;
char *file1[20];			//array to hold file names (for printing to screen)
char fileArray[20][100];//array to read in file names
char FileType[20];		//array to hold file type (BITMAP or TARGA)
int imagetype,next=0,count=0;

typedef struct {
	int stereo;
	int screenwidth;
	int screenheight;
} CAMERA;

struct Image {
    unsigned long sizeX;
    unsigned long sizeY;
    char *data;
};

typedef struct Image Image;
Image image1[20];					//holds bitmaps
CAMERA camera;

Texture texture[20];					//holds targa




/********************************************************
 						Load a 24bit bitmap
			does not have to be sqaure anymore!
						24bit bitmaps only
							1 plane only
/*******************************************************/

// quick and dirty bitmap loader...for 24 bit bitmaps with 1 plane only.
// See http://www.dcs.ed.ac.uk/~mxr/gfx/2d/BMP.txt for more info.
// if mesa ever gets glaux, let me know.

int ImageLoad(char *filename, Image *image) {
    FILE *file;
    unsigned long size;                 // size of the image in bytes.
    unsigned long i;                    // standard counter.
    unsigned short int planes;          // number of planes in image (must be 1)
    unsigned short int bpp;             // number of bits per pixel (must be 24)
    char temp;                          // used to convert bgr to rgb color.

    // ensure the file is there.
    if ((file = fopen(filename, "rb"))==NULL)
    {
	printf("File Not Found : %s\n",filename);
	return 0;
    }

    // seek through the bmp header, up to the width/height:
    fseek(file, 18, SEEK_CUR);

    // read the width
    if ((i = fread(&image->sizeX, 4, 1, file)) != 1) {
	printf("Error reading width from %s.\n", filename);
	return 0;
    }
    printf("Width of %s: %lu\n", filename, image->sizeX);


    // read the height
    if ((i = fread(&image->sizeY, 4, 1, file)) != 1) {
	printf("Error reading height from %s.\n", filename);
	return 0;

    }
    printf("Height of %s: %lu\n", filename, image->sizeY);

    // calculate the size (assuming 24 bits or 3 bytes per pixel).
    size = image->sizeX * image->sizeY * 3;

    // read the planes
    if ((fread(&planes, 2, 1, file)) != 1) {
	printf("Error reading planes from %s.\n", filename);
	return 0;
    }
    if (planes != 1) {
	printf("Planes from %s is not 1: %u\n", filename, planes);
	return 0;
    }

    // read the bpp
    if ((i = fread(&bpp, 2, 1, file)) != 1) {
	printf("Error reading bpp from %s.\n", filename);
	return 0;
    }
    if (bpp != 24) {
	printf("Bpp from %s is not 24: %u\n", filename, bpp);
	return 0;
    }

    // seek past the rest of the bitmap header.
    fseek(file, 24, SEEK_CUR);

    // read the data.
    image->data = (char *) malloc(size);
    if (image->data == NULL) {
	printf("Error allocating memory for color-corrected image data");
	return 0;
    }

    if ((i = fread(image->data, size, 1, file)) != 1) {
	printf("Error reading image data from %s.\n", filename);
	return 0;
    }

    for (i=0;i<size;i+=3) { // reverse all of the colors. (bgr -> rgb)
	temp = image->data[i];
	image->data[i] = image->data[i+2];
	image->data[i+2] = temp;
    }

    // we're done.
    return 1;
}


/********************************************************
						Load a TGA file
/*******************************************************/


BOOL LoadTGA(Texture * texture,const char * filename)				/* Load a TGA file */
{
	FILE * fTGA;													/* File pointer to texture file */
	fTGA = fopen(filename, "rb");									/* Open file for reading */

	if(fTGA == NULL)												/* If it didn't open.... */
	{
		printf("Error could not open %s", filename);				/* Display an error message */
		return False;												/* Exit function */
	}

	if(fread(&tgaheader, sizeof(TGAHeader), 1, fTGA) == 0)			/* Attempt to read 12 byte header from file */
	{
		printf("Error could not read file header");					/* If it fails, display an error message */
		if(fTGA != NULL)												/* Check to seeiffile is still open */
		{
			fclose(fTGA);												/* If it is, close it */
		}
		return False;													/* Exit function */
	}

	if(memcmp(uTGAcompare, &tgaheader, sizeof(tgaheader)) == 0)	/* See if header matches the predefined header of */
	{																/* an Uncompressed TGA image */
		LoadUncompressedTGA(texture, filename, fTGA);					/* If so, jump to Uncompressed TGA loading code */
	}
	else if(memcmp(cTGAcompare, &tgaheader, sizeof(tgaheader)) == 0)	/* See if header matches the predefined header of */
	{																	/* an RLE compressed TGA image */
		LoadCompressedTGA(texture, filename, fTGA);						/* If so, jump to Compressed TGA loading code */
	}
	else																/* If header matches neither type */
	{
		printf("Error TGA file be type 2 or type 10 ");				/* Display an error */
		fclose(fTGA);
		return False;												/* Exit function */
	}
	return True;														/* All went well, continue on */
}

BOOL LoadUncompressedTGA(Texture * texture, const char * filename, FILE * fTGA)	/* Load an uncompressed TGA (note, much of this code is based on NeHe's */
{
	GLuint cswap;															/* TGA Loading code nehe.gamedev.net) */
	if(fread(tga.header, sizeof(tga.header), 1, fTGA) == 0)				/* Read TGA header */
	{
		printf("Error could not read info header");							/* Display error */
		if(fTGA != NULL)													/* if file is still open */
		{
			fclose(fTGA);													/* Close it */
		}
		return False;														/* Return failular */
	}

	texture->width  = tga.header[1] * 256 + tga.header[0];					/* Determine The TGA Width	(highbyte*256+lowbyte) */
	texture->height = tga.header[3] * 256 + tga.header[2];					/* Determine The TGA Height	(highbyte*256+lowbyte) */
	texture->bpp	= tga.header[4];										/* Determine the bits per pixel */
	tga.Width		= texture->width;										/* Copy width into local structure */
	tga.Height		= texture->height;										/* Copy height into local structure */
	tga.Bpp			= texture->bpp;											/* Copy BPP into local structure */

	if((texture->width <= 0) || (texture->height <= 0) || ((texture->bpp != 24) && (texture->bpp !=32)))	/* Make sure all information is valid */
	{
		printf("Error invalid texture information");						/* Display Error */
		if(fTGA != NULL)													/* Check if file is still open */
		{
			fclose(fTGA);													/* If so, close it */
		}
		return False;														/* Return failed */
	}

	if(texture->bpp == 24)													/* If the BPP of the image is 24... */
	{
		texture->type	= GL_RGB;											/* Set Image type to GL_RGB */
	}
	else																	/* Else if its 32 BPP */
	{
		texture->type	= GL_RGBA;											/* Set image type to GL_RGBA */
	}

	tga.bytesPerPixel	= (tga.Bpp / 8);									/* Compute the number of BYTES per pixel */
	tga.imageSize		= (tga.bytesPerPixel * tga.Width * tga.Height);		/* Compute the total amout ofmemory needed to store data */
	texture->imageData	= malloc(tga.imageSize);							/* Allocate that much memory */

	if(texture->imageData == NULL)											/* If no space was allocated */
	{
		printf("Error could not allocate memory for image");				/* Display Error */
		fclose(fTGA);														/* Close the file */
		return False;														/* Return failed */
	}

	if(fread(texture->imageData, 1, tga.imageSize, fTGA) != tga.imageSize)	/* Attempt to read image data */
	{
		printf("Error could not read image data");							/* Display Error */
		if(texture->imageData != NULL)										/* If imagedata has data in it */
		{
			free(texture->imageData);										/* Delete data from memory */
		}
		fclose(fTGA);														/* Close file */
		return False;														/* Return failed */
	}

	/* Byte Swapping Optimized By Steve Thomas */
	for(cswap = 0; cswap < (int)tga.imageSize; cswap += tga.bytesPerPixel)
	{
		texture->imageData[cswap] ^= texture->imageData[cswap+2] ^=
		texture->imageData[cswap] ^= texture->imageData[cswap+2];
	}

	fclose(fTGA);															/* Close file */
	return True;															/* Return success */
}


BOOL LoadCompressedTGA(Texture * texture,const char * filename, FILE * fTGA)		/* Load COMPRESSED TGAs */
{
	GLuint pixelcount	= tga.Height * tga.Width;							/* Nuber of pixels in the image */
	GLuint currentpixel	= 0;												/* Current pixel being read */
	GLuint currentbyte	= 0;												/* Current byte */
	GLubyte * colorbuffer = (GLubyte *)malloc(tga.bytesPerPixel);			/* Storage for 1 pixel */

	if(fread(tga.header, sizeof(tga.header), 1, fTGA) == 0)				/* Attempt to read header */
	{
		printf("Error could not read info header");							/* Display Error */
		if(fTGA != NULL)													/* If file is open */
		{
			fclose(fTGA);													/* Close it */
		}
		return False;														/* Return failed */
	}

	texture->width  = tga.header[1] * 256 + tga.header[0];					/* Determine The TGA Width	(highbyte*256+lowbyte) */
	texture->height = tga.header[3] * 256 + tga.header[2];					/* Determine The TGA Height	(highbyte*256+lowbyte) */
	texture->bpp	= tga.header[4];										/* Determine Bits Per Pixel */
	tga.Width		= texture->width;										/* Copy width to local structure */
	tga.Height		= texture->height;										/* Copy width to local structure */
	tga.Bpp			= texture->bpp;											/* Copy width to local structure */

	if((texture->width <= 0) || (texture->height <= 0) || ((texture->bpp != 24) && (texture->bpp !=32)))	/*Make sure all texture info is ok */
	{
		printf("Error Invalid texture information");						/* If it isnt...Display error */
		if(fTGA != NULL)													/* Check if file is open */
		{
			fclose(fTGA);													/* Ifit is, close it */
		}
		return False;														/* Return failed */
	}

	tga.bytesPerPixel	= (tga.Bpp / 8);									/* Compute BYTES per pixel */
	tga.imageSize		= (tga.bytesPerPixel * tga.Width * tga.Height);		/* Compute amout of memory needed to store image */
	texture->imageData	= (GLubyte *)malloc(tga.imageSize);					/* Allocate that much memory */

	if(texture->imageData == NULL)											/* If it wasnt allocated correctly.. */
	{
		printf("Error could not allocate memory for image");				/* Display Error */
		fclose(fTGA);														/* Close file */
		return False;														/* Return failed */
	}

	do
	{
		GLubyte chunkheader = 0;											/* Storage for "chunk" header */

		if(fread(&chunkheader, sizeof(GLubyte), 1, fTGA) == 0)				/* Read in the 1 byte header */
		{
			printf("Error could not read RLE header");						/*Display Error */
			if(fTGA != NULL)												/* If file is open */
			{
				fclose(fTGA);												/* Close file */
			}
			if(texture->imageData != NULL)									/* If there is stored image data */
			{
				free(texture->imageData);									/* Delete image data */
			}
			return False;													/* Return failed */
		}

		if(chunkheader < 128)												/* If the ehader is < 128, it means the that is the number of RAW color packets minus 1 */
		{
			short counter;													/* that follow the header */
			chunkheader++;													/* add 1 to get number of following color values */
			for(counter = 0; counter < chunkheader; counter++)				/* Read RAW color values */
			{
				if(fread(colorbuffer, 1, tga.bytesPerPixel, fTGA) != tga.bytesPerPixel) /* Try to read 1 pixel */
				{
					printf("Error could not read image data");				/* IF we cant, display an error */

					if(fTGA != NULL)										/* See if file is open */
					{
						fclose(fTGA);										/* If so, close file */
					}

					if(colorbuffer != NULL)									/* See if colorbuffer has data in it */
					{
						free(colorbuffer);									/* If so, delete it */
					}

					if(texture->imageData != NULL)										/* See if there is stored Image data */
					{
						free(texture->imageData);										/* If so, delete it too */
					}

					return False;														/* Return failed */
				}
																						/* write to memory */
				texture->imageData[currentbyte		] = colorbuffer[2];				    /* Flip R and B vcolor values around in the process */
				texture->imageData[currentbyte + 1	] = colorbuffer[1];
				texture->imageData[currentbyte + 2	] = colorbuffer[0];

				if(tga.bytesPerPixel == 4)												/* if its a 32 bpp image */
				{
					texture->imageData[currentbyte + 3] = colorbuffer[3];				/* copy the 4th byte */
				}

				currentbyte += tga.bytesPerPixel;										/* Increase thecurrent byte by the number of bytes per pixel */
				currentpixel++;															/* Increase current pixel by 1 */

				if(currentpixel > pixelcount)											/* Make sure we havent read too many pixels */
				{
					printf("Error too many pixels read");								/* if there is too many... Display an error! */

					if(fTGA != NULL)													/* If there is a file open */
					{
						fclose(fTGA);													/* Close file */
					}

					if(colorbuffer != NULL)												/* If there is data in colorbuffer */
					{
						free(colorbuffer);												/* Delete it */
					}

					if(texture->imageData != NULL)										/* If there is Image data */
					{
						free(texture->imageData);										/* delete it */
					}

					return False;														/* Return failed */
				}
			}
		}
		else																			/* chunkheader > 128 RLE data, next color  reapeated chunkheader - 127 times */
		{
			short counter;
			chunkheader -= 127;															/* Subteact 127 to get rid of the ID bit */
			if(fread(colorbuffer, 1, tga.bytesPerPixel, fTGA) != tga.bytesPerPixel)		/* Attempt to read following color values */
			{
				printf("Error could not read from file");			/* If attempt fails.. Display error (again) */

				if(fTGA != NULL)														/* If thereis a file open */
				{
					fclose(fTGA);														/* Close it */
				}

				if(colorbuffer != NULL)													/* If there is data in the colorbuffer */
				{
					free(colorbuffer);													/* delete it */
				}

				if(texture->imageData != NULL)											/* If thereis image data */
				{
					free(texture->imageData);											/* delete it */
				}

				return False;															/* return failed */
			}

			for(counter = 0; counter < chunkheader; counter++)					/* copy the color into the image data as many times as dictated */
			{																			/* by the header */
				texture->imageData[currentbyte		] = colorbuffer[2];					/* switch R and B bytes areound while copying */
				texture->imageData[currentbyte + 1	] = colorbuffer[1];
				texture->imageData[currentbyte + 2	] = colorbuffer[0];

				if(tga.bytesPerPixel == 4)												/* If TGA images is 32 bpp */
				{
					texture->imageData[currentbyte + 3] = colorbuffer[3];				/* Copy 4th byte */
				}

				currentbyte += tga.bytesPerPixel;										/* Increase current byte by the number of bytes per pixel */
				currentpixel++;															/* Increase pixel count by 1 */

				if(currentpixel > pixelcount)											/* Make sure we havent written too many pixels */
				{
					printf("Error too many pixels read");								/* if there is too many... Display an error! */

					if(fTGA != NULL)													/* If there is a file open */
					{
						fclose(fTGA);													/* Close file */
					}

					if(colorbuffer != NULL)												/* If there is data in colorbuffer */
					{
						free(colorbuffer);												/* Delete it */
					}

					if(texture->imageData != NULL)										/* If there is Image data */
					{
						free(texture->imageData);										/* delete it */
					}

					return False;														/* Return failed */
				}
			}
		}
	}

	while(currentpixel < pixelcount);													/* Loop while there are still pixels left */
	fclose(fTGA);																		/* Close the file */
	return True;																		/* return success */
}



/********************************************************
   			Handle a window reshape/resize
********************************************************/
void HandleReshape(int w,int h)
{
   camera.screenwidth = w;							//set new window width
   camera.screenheight = h;						//set new window height
	glViewport(0,0,(GLsizei)w,(GLsizei)h);		//resize the viewport
}


/********************************************************
					Function to draw text
********************************************************/
void DrawGLText(int x,int y,char *s)
{
   int lines;
   char *p;

   glMatrixMode(GL_PROJECTION);
   glPushMatrix();
   glLoadIdentity();
   glOrtho(0,glutGet(GLUT_WINDOW_WIDTH),0,glutGet(GLUT_WINDOW_HEIGHT),-1,1);
   glMatrixMode(GL_MODELVIEW);
   glPushMatrix();
   glLoadIdentity();

   glRasterPos2i(x,y);
   for (p=s,lines=0;*p;p++) {
      if (*p == '\n' || *p == '\r') {
         lines++;
         glRasterPos2i(x,y-(lines*13));
      } else {
      	glutBitmapCharacter(GLUT_BITMAP_8_BY_13,*p);
		}
   }

   glPopMatrix();
   glMatrixMode(GL_PROJECTION);
   glPopMatrix();
}


/********************************************************
		Sets up viewports for normal/stereo viewing
		and draws the pixels of the image data
********************************************************/
void HandleDisplay(void)
{
	int x,y;
	int i,j;
	FILE *pFile;
	char next_1[10],next_2[10],count_d[10],sizeX[10],sizeY[10];

//write number of files and current file displayed to file
//this is so that they can be read back into an array
//very bad way of doing things...another way??

	i = next;

	pFile = fopen("data", "w+");
	if (FileType[i]==BITMAP)
		fprintf(pFile, "%d %d %d %d %d", next+1, next+2, count, image1[i].sizeX, image1[i].sizeY);
	else if (FileType[i]==TARGA)
		fprintf(pFile, "%d %d %d %d %d", next+1, next+2, count, texture[i].width, texture[i].height);
	rewind(pFile);
	fscanf(pFile, "%s",next_1);
	fscanf(pFile, "%s",next_2);
	fscanf(pFile, "%s",count_d);
	fscanf(pFile, "%s",sizeX);
	fscanf(pFile, "%s",sizeY);
	fclose(pFile);

//prevent from cycling into unused memory


	if(i>(count-1)) {
		i=0;
		next=0;
	}
	if(i<0) {
		i=count-2;
		next=count-2;
	}

//clear buffers
   glDrawBuffer(GL_BACK);
   glClear(GL_COLOR_BUFFER_BIT);

//set cursor visibility
	if(cursor==0)
		glutSetCursor(GLUT_CURSOR_NONE);
	else
		glutSetCursor(GLUT_CURSOR_CROSSHAIR);


//left image projection
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	if (camera.stereo == DUALSTEREO) {
			gluOrtho2D(0,camera.screenwidth/2,0,camera.screenheight);
         glViewport(0,0,camera.screenwidth/2,camera.screenheight);
	}
 	else {
			gluOrtho2D(0,camera.screenwidth,0,camera.screenheight);
		   glViewport(0,0,camera.screenwidth,camera.screenheight);
	}
	glMatrixMode(GL_MODELVIEW);
	glDrawBuffer(GL_BACK_LEFT);
	glLoadIdentity();
	glPushMatrix();
	if(FileType[i]==TARGA) {						//centre left TGA image
		if(DUALSTEREO)
			x = (camera.screenwidth/2 - texture[i].width)/2;
		else
			x = (camera.screenwidth - texture[i].width)/2;
		y = (camera.screenheight - texture[i].height)/2;
		glRasterPos2i(x,y);
		glDrawPixels(texture[i].width, texture[i].height, texture[i].type, GL_UNSIGNED_BYTE, texture[i].imageData);
	}
	else {											//centre left BMP image
		if(DUALSTEREO)
			x = (camera.screenwidth/2 - image1[i].sizeX)/2;
		else
			x = (camera.screenwidth - image1[i].sizeX)/2;
		y = (camera.screenheight - image1[i].sizeY)/2;
		glRasterPos2i(x,y);
		glDrawPixels(image1[i].sizeX, image1[i].sizeY, GL_RGB, GL_UNSIGNED_BYTE, image1[i].data);
	}
	if(info) {
		glColor3f(1.0,0.0,0.0);
		DrawGLText(10,camera.screenheight-10, "Stereo Image Viewer by Aidan Crees");
		DrawGLText(10,camera.screenheight-25, "Left image:");
		DrawGLText(210,camera.screenheight-25, file1[i]);
		DrawGLText(10,camera.screenheight-40, "Width:");
		DrawGLText(110,camera.screenheight-40, sizeX);
		DrawGLText(10,camera.screenheight-55, "Height:");
		DrawGLText(125,camera.screenheight-55, sizeY);
		DrawGLText(10,10, "Image    of   ");
		DrawGLText(110,10, next_1);
		DrawGLText(195,10, count_d);
	}
	if(DisplayListContents) {
		glColor3f(1.0,0.0,0.0);
		DrawGLText(10,camera.screenheight-85, "Files loaded...");
		for(j=0;j<count;j++)
			DrawGLText(10,camera.screenheight-(15*j+100), file1[j]);
	}
	if(DisplayHelp) {
		glColor3f(0.0,0.9,0.0);
		DrawGLText(camera.screenwidth-700,camera.screenheight-10, "Program keys");
		DrawGLText(camera.screenwidth-700,camera.screenheight-40, "left arrow      previous image");
		DrawGLText(camera.screenwidth-700,camera.screenheight-55, "right arrow     next image");
		DrawGLText(camera.screenwidth-700,camera.screenheight-70, "i               toggle image information");
		DrawGLText(camera.screenwidth-700,camera.screenheight-85, "c               toggle cursor visibility");
		DrawGLText(camera.screenwidth-700,camera.screenheight-100, "f               toggle fullscreen");
		DrawGLText(camera.screenwidth-700,camera.screenheight-115, "l               toggle image list display");
		DrawGLText(camera.screenwidth-700,camera.screenheight-130, "h               toggle help display");
		DrawGLText(camera.screenwidth-700,camera.screenheight-145, "q,ESC           exit program");

	}
	glPopMatrix();


//right image projection
	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
	if (camera.stereo == DUALSTEREO) {
		gluOrtho2D(camera.screenwidth/2,camera.screenwidth,0,camera.screenheight);
		glViewport(camera.screenwidth/2,0,camera.screenwidth/2,camera.screenheight);
	}
	else {
		//gluOrtho2D(0,camera.screenwidth,0,camera.screenheight);
		glViewport(0,0,camera.screenwidth,camera.screenheight);
	}
	glMatrixMode(GL_MODELVIEW);
	glDrawBuffer(GL_BACK_RIGHT);
	glLoadIdentity();
	glPushMatrix();
	if(FileType[i+1]==TARGA) {						//centre right TGA image
		if(DUALSTEREO)
			x = (camera.screenwidth/2 - texture[i+1].width)/2;
		else
			x = (camera.screenwidth - texture[i+1].width)/2;
		y = (camera.screenheight - texture[i+1].height)/2;
		glRasterPos2i(camera.screenwidth/2+x,y);
		glDrawPixels(texture[i+1].width, texture[i+1].height, texture[i+1].type, GL_UNSIGNED_BYTE, texture[i+1].imageData);
	}
	else {											//centre right BMP image
	if(DUALSTEREO)
		x = (camera.screenwidth/2 - image1[i+1].sizeX)/2;
	else
		x = (camera.screenwidth - image1[i+1].sizeX)/2;
	y = (camera.screenheight - image1[i+1].sizeY)/2;
	glRasterPos2i(camera.screenwidth/2+x,y);
	glDrawPixels(image1[i+1].sizeX, image1[i+1].sizeY, GL_RGB, GL_UNSIGNED_BYTE, image1[i+1].data);
	}
		if(info) {
		glColor3f(1.0,0.0,0.0);
		DrawGLText(10,camera.screenheight-10, "Stereo Image Viewer by Aidan Crees");
		DrawGLText(10,camera.screenheight-25, "Right image:");
		DrawGLText(230,camera.screenheight-25, file1[i+1]);
		DrawGLText(10,camera.screenheight-40, "Width:");
		DrawGLText(110,camera.screenheight-40, sizeX);
		DrawGLText(10,camera.screenheight-55, "Height:");
		DrawGLText(125,camera.screenheight-55, sizeY);
		DrawGLText(10,10, "Image    of   ");
		DrawGLText(110,10, next_2);
		DrawGLText(195,10, count_d);
	}
	glPopMatrix();

//misc stuff
	glutSwapBuffers();			//swap the buffers
	glutPostRedisplay();			//update display (for text)

}

/********************************************************
					Handles keyboard input
********************************************************/
void HandleKeyboard(unsigned char key, int x, int y)
{
	switch (key) {
	case 'i':
	case 'I':
		info = !info;
		break;
	case 'c':
	case 'C':
		cursor = !cursor;
		break;
	case 'f':
	case 'F':
		if(screen)
			if(DUALSTEREO)
			 	glutReshapeWindow(1000,500);
			else
				glutReshapeWindow(500,500);
		else
			glutFullScreen();
		screen = !screen;
		break;
	case 'h':
	case 'H':
		DisplayHelp = !DisplayHelp;
		break;
	case 'l':
	case 'L':
		DisplayListContents = !DisplayListContents;
		break;
	case SPACE:
		DisplayListContents = 0;
		DisplayHelp = 0;
		info = 0;
		break;
	case ESC:
	case 'Q':
	case 'q':
		exit(0);
		break;
	}
}

/********************************************************
					Handles keyboard input
********************************************************/
void HandleSpecialKeyboard(int key, int x, int y)
{
	switch(key) {
		case GLUT_KEY_LEFT:
			next=next-2;
			break;
		case GLUT_KEY_RIGHT:
			next=next+2;
			break;
		default:
			return;
		}
}



/********************************************************
		Reads files and other initialise stuff
********************************************************/
int ReadFiles(char *listname)
{
	int i,len;
	char *pch1, *pch2;
	FILE *File;
   char c;

//processes image type for non-list images
	pch1 = strstr (file1[0], ".tga"); //searches file1[0] for any occurence of string ".tga"
	pch2 = strstr (file1[1], ".tga"); //searches file1[1] for any occurence of string ".tga"
	if (pch1!=NULL && pch2!=NULL) {	//if both files contain string ".tga" then set image type to TARGA
		FileType[0]=TARGA;
		FileType[1]=TARGA;
	}
	pch1 = strstr (file1[0], ".bmp");
	pch2 = strstr (file1[1], ".bmp");
	if (pch1!=NULL && pch2!=NULL) {
		FileType[0]=BITMAP;
		FileType[1]=BITMAP;
	}

//processes image type for images in a list
	if(imagetype==LIST) {

	     if ((File = fopen(listname, "r"))==NULL) {
    		fprintf(stderr, "File Not Found: %s\n",listname);	//open list
			exit(1);
		  }
	     do {
		  		c = fgetc(File);
				if(c == '\n') count++;						//count number of images in list
		  } while (c != EOF);
		  rewind(File);										//put pointer back at start of list
		  fprintf(stderr, "Found %d files in '%s'\n", count, listname);
		  fprintf(stderr, "Loading images...\n");
		  for(i=0;i<count;i++) {
		  fgets(fileArray[i], 100, File);				//get image names and store them in fileArray[i]
		  len = strlen(fileArray[i]);
		  strncpy(fileArray[i],fileArray[i],len-1);	//gets rid of newline character at end of filename
		  fileArray[i][len-1]='\0';						//terminates line
		  fprintf(stderr, "Filename %d: %s\n",i,fileArray[i]);
		  }
		  fclose(File);

		  for(i=0;i<count;i++) {
		  	pch1 = strstr (fileArray[i], ".tga");
		  	pch2 = strstr (fileArray[i], ".tga");
		  	if (pch1!=NULL && pch2!=NULL) {
				FileType[i]=TARGA;							//set current image type to TARGA
				file1[i] = fileArray[i];					//store filename into file1[i]
    		}

			pch1 = strstr (fileArray[i], ".bmp");
			pch2 = strstr (fileArray[i], ".bmp");
	     	if (pch1!=NULL && pch2!=NULL) {
				FileType[i]=BITMAP;
				file1[i] = fileArray[i];
			}
		  }//for
	}//LIST

	for(i=0;i<count;i++) {		//processes image type for each image (default count = 2)
	  	switch(FileType[i]) {			//which type of image to load BMP or TGA?
			case BITMAP:
				{
					/*image1[i] = (Image *) malloc(sizeof(Image)); 		//load bitmap
    				if (image1[i] == NULL) {
						fprintf(stderr, "Error allocating space for image");
						exit(0);
    				}*/
					if (!ImageLoad(file1[i], &image1[i])) {
						exit(1);
    				}
					glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
					break;
				}
			case TARGA:
				{
					if  (!LoadTGA(&texture[i], file1[i]))	//load TGA
						exit(1);
					break;
				}
		}//case
	}//for
}//ReadFiles-500

/********************************************************
								Main
********************************************************/
int main(int argc, char **argv)
{
	int i;
	
	camera.stereo = NOSTEREO;
	camera.screenwidth = 500;
	camera.screenheight = 500;

	if (argc < 3) {
	 fprintf (stderr, "------------------------------------------------------------------------------\n");
	 fprintf (stderr, "		STEREO IMAGE VIEWER BY AIDAN CREES, Jan-Feb 2004.\n");
	 fprintf (stderr, "------------------------------------------------------------------------------\n");
	 fprintf (stderr, "Usage: %s <leftimage> <rightimage> [OPTION]\n\n", argv[0]);
	 fprintf (stderr, "Images must be either in BMP or TGA format!\n");
	 fprintf (stderr, "If the -l flag is set, enter <listname> instead of <leftimage> and <rightimage>\n\n");
	 fprintf (stderr, "Command line options\n");
	 fprintf (stderr, "			-f 		fullscreen\n");
	 fprintf (stderr, "			-ss 		dual screen stereo\n");
	 fprintf (stderr, "			-l 		specify file list mode\n");
	 fprintf (stderr, "Program options\n");
	 fprintf (stderr, "			left arrow 	previous image\n");
	 fprintf (stderr, "			right arrow 	next image\n");
	 fprintf (stderr, "			i 		toggle image information\n");
	 fprintf (stderr, "			c 		toggle cursor visibility\n");
	 fprintf (stderr, "			f 		toggle fullscreen\n");
	 fprintf (stderr, "			l 		toggle image list display\n");
	 fprintf (stderr, "			h 		display this screen\n");
	 fprintf (stderr, "			q 		exit program\n");
	 exit(0);
	}
	for (i=1;i<argc;i++) {
 		if (strcmp(argv[i],"-f") == 0)
 			fullscreen = !fullscreen;
		if (strcmp(argv[i],"-ss") == 0) {
         camera.stereo = DUALSTEREO;
			camera.screenwidth *= 2;
		}
		if (strcmp(argv[i],"-l") == 0)
			imagetype=LIST;
	}

	file1[0] = argv[1];  //copies left image filename to file1
	file1[1] = argv[2];
	if(imagetype!=LIST)	//if not processing a list, set number of images 2 by default
		count=2;

	ReadFiles(argv[1]);		//load images

	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
	glutCreateWindow("Stereo Pair Viewer by Aidan Crees");
	glutReshapeWindow(camera.screenwidth, camera.screenheight);
	if (fullscreen)
		glutFullScreen();
	glutDisplayFunc(HandleDisplay);
	glutReshapeFunc(HandleReshape);
	glutKeyboardFunc(HandleKeyboard);
	glutSpecialFunc(HandleSpecialKeyboard);

	glutMainLoop();
	return(0);
}