/****************************************************************

Texture Demo Program 

Designed to illustrate texture mapping and the derivation of
textures from images.

Based on the Red Book example program p. 368, second ed.

Adapted by H. Masterman 22 November 1999
Revised by H. Masterman 27 November 2000
Revised by H. Masterman April 2005 to use LoadBimap instead of SGI
	Image Product Library


*****************************************************************/


#include <GL/glut.h>
#include <stdlib.h>
#include <stdio.h>
#include <iostream.h>
#include <windows.h>



/*	Create checkerboard texture	*/
#define	checkImageWidth 64
#define	checkImageHeight 64
static GLubyte checkImage[checkImageHeight][checkImageWidth][4];
static GLubyte otherImage[checkImageHeight][checkImageWidth][4];

static GLuint texName[2];


float theta=0.0;  //rotation angle
int rotate = 0; // boolean flag for rotation

int LoadBitmap(char *filename, int num_texture) 
{ 

   unsigned char *l_texture;	// a pointer to the memory zone where I will load 
								// my texture. Each point on the texture is represented
								// by 4 values ( RGBA )
   int i, j=0;
   FILE *l_file;
   BITMAPFILEHEADER fileheader; // stores type and size of texture image
   BITMAPINFOHEADER infoheader;	// texture image information ( width and height )
   RGBTRIPLE rgb;

    
 
   if( (l_file = fopen(filename, "rb"))==NULL) 
   {cout<<"Unable to open file:"<<filename<<endl;
   return -1;}
   fread(&fileheader, sizeof(fileheader), 1, l_file);
   fseek(l_file, sizeof(fileheader), SEEK_SET);
   fread(&infoheader, sizeof(infoheader), 1, l_file);

   l_texture = (byte *) malloc(infoheader.biWidth * infoheader.biHeight * 4);
   memset(l_texture, 0, infoheader.biWidth * infoheader.biHeight * 4);

   // Load image into structure ( for each pixel store the RGBA component )
   for (i=0; i < infoheader.biWidth*infoheader.biHeight; i++)
   { 
      fread(&rgb, sizeof(rgb), 1, l_file); 

      l_texture[j+0] = rgb.rgbtRed;		// Red component
      l_texture[j+1] = rgb.rgbtGreen;	// Green component
      l_texture[j+2] = rgb.rgbtBlue;	// Blue component
	
      l_texture[j+3] = 155;				// Alpha value
      j += 4; // Go to the next position
   }

   fclose(l_file); // Closes the file stream

   glBindTexture(GL_TEXTURE_2D, num_texture); 

   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

   
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, infoheader.biWidth, infoheader.biHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, l_texture);
   //gluBuild2DMipmaps(GL_TEXTURE_2D, 4, infoheader.biWidth, infoheader.biHeight, GL_RGBA, GL_UNSIGNED_BYTE, l_texture);
	
   free(l_texture) ;

   return(num_texture);

}
void makeCheckImages(void)
{
   int i, j, c;
    
   for (i = 0; i < checkImageHeight; i++) {
      for (j = 0; j < checkImageWidth; j++) {
         c = ((((i&0x2)==0)^((j&0x2))==0))*255;
         checkImage[i][j][0] = (GLubyte) c;
         checkImage[i][j][1] = (GLubyte) c;
         checkImage[i][j][2] = (GLubyte) c;
         checkImage[i][j][3] = (GLubyte) 255;
         c = ((((i&0x4)==0)^((j&0x4))==0))*255;
         otherImage[i][j][0] = (GLubyte) c;
         otherImage[i][j][1] = (GLubyte) 0;
         otherImage[i][j][2] = (GLubyte) 0;
         otherImage[i][j][3] = (GLubyte) 255;
      }
   }
}

void init(void)
{    
   int i;
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel(GL_FLAT);
   glEnable(GL_DEPTH_TEST);

   makeCheckImages();  //generate two procedurally-based textures
   LoadBitmap("julie.bmp", 1);  //generate an image texture from julie.bmp

  
   glBindTexture(GL_TEXTURE_2D, 2);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, checkImageWidth, 
                checkImageHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 
                otherImage);
   
   
   // enable everything you need
   glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
   glEnable(GL_TEXTURE_2D);
   glEnable(GL_LIGHTING);
   glEnable(GL_LIGHT0);

   // get the version information

	cout<<"Version: "<<glGetString(GL_VERSION)<<endl;
	cout<<"Renderer: "<<glGetString(GL_RENDERER)<<endl;
	cout<<"Vendor: "<<glGetString(GL_VENDOR)<<endl;
	


}

void display(void)
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
   glMatrixMode(GL_MODELVIEW);

   //rotation to view the texture from different directions
   
   glLoadIdentity();
   glTranslatef(0.0, 0.0, -3.6);
   glRotatef(theta, 0, 1, 0);

   // bind texture 1 and draw a polygon	  
   
   glBindTexture(GL_TEXTURE_2D, 1);
   
   glBegin(GL_POLYGON);
   glNormal3f(-1,0,1);
   float juliecolor[4]={1.0,1.0,1.0,1.0};
   glMaterialfv(GL_FRONT,GL_DIFFUSE, juliecolor);
   glTexCoord2f(0.0, 0.0); glVertex3f(-1.4, -1.0, 0.0);
   glTexCoord2f(0.0, 1.0); glVertex3f(-1.4, 1.0, 0.0);
   glTexCoord2f(1.0, 1.0); glVertex3f(0.0, 1.0, 1.4);
   glTexCoord2f(1.0, 0.0); glVertex3f(0.0, -1.0, 1.4);
   glEnd();
   
// bind texture 2 and draw a polygon  
   
   glBindTexture(GL_TEXTURE_2D, 2);
   glNormal3f(1,0,1);
   
   glBegin(GL_QUADS);
   glTexCoord2f(0.0, 0.0); glVertex3f(1.0, -1.0, 0.0);
   glTexCoord2f(0.0, 1.0); glVertex3f(1.0, 1.0, 0.0);
   glTexCoord2f(1.0, 1.0); glVertex3f(2.41421, 1.0, -1.41421);
   glTexCoord2f(1.0, 0.0); glVertex3f(2.41421, -1.0, -1.41421);
   glEnd();
   
   glFlush();
   glutSwapBuffers();
}

void idle (void) 
// this function provides animation to see how geometry affects textures

	{ 
	if (rotate) theta += 1.0; //yes, I know I am letting this increase out of bounds!
	glutPostRedisplay();
	}

void reshape(int w, int h)
{
   glViewport(0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
   gluPerspective(60.0, (GLfloat) w/(GLfloat) h, 1.0, 30.0);
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
   glTranslatef(0.0, 0.0, -3.6);
}

void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 27:
         exit(0);
         break;
	  case 'r':
		  rotate =1; // turn rotation on
		  break;
	  case 's':
		  rotate = 0;  // turn rotation off
   }
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize(800, 600);
   glutInitWindowPosition(50, 50);
   glutCreateWindow("Texture Demonstration");
   init();
   glutReshapeFunc(reshape);
   glutDisplayFunc(display);
   glutIdleFunc(idle);
   glutKeyboardFunc (keyboard);
   glutMainLoop();
   return 0; 
}