// FILE:  tex_lightdemo_modulate.cpp
 
#include <GL/glut.h>
#include <stdlib.h>
#include <fstream>

//Info needed for the  images:
GLubyte myImage256[256][256][4];
GLuint texName[2];  
 
long depth=0;       //used for level of recursion
bool wire=true;
bool smooth=true;
bool image = false;

// The vertices of the square:
float s1[3] = {-1.0, -1.0, 0.0};
float s2[3] = {1.0, -1.0, 0.0};
float s3[3] = {1.0, 1.0, 0.0};
float s4[3] = {-1.0, 1.0, 0.0};

// The face normal:
float norm[3] = {0.0, 0.0, 1.0};
   

//GLOBAL VARIABLES FOR LIGHT0:
GLfloat  diff_red,  diff_green,  diff_blue;    //diffuse

void loadImages();
void image_on_wall();
void init();
void display();
void normalize(float v[3]);
void drawtriangle(float v1[3], float v2[3], float v3[3]);
void subdivide(float v1[3], float v2[3], float v3[3], long depth);
void drawsurface();
void reshape (int w, int h);
void keyboard(unsigned char key, int x, int y);
void mykeys(int key, int x, int y);

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize (450, 450); 
   glutInitWindowPosition (10, 10);
   glutCreateWindow (argv[0]);
   init ();
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape);
   glutKeyboardFunc(keyboard);
   glutSpecialFunc(mykeys);
   glutMainLoop();
   return 0;
}


void init() 
{
   glClearColor (0.0, 0.0, 0.0, 0.0);


//Define the material:
   GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
   GLfloat mat_diffuse[] = {1.0, 1.0, 1.0, 1.0};
   GLfloat mat_shininess[] = { 100.0 };
  
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
   glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);

//light
   diff_red = 1.0;  diff_green = 1.0; diff_blue = 1.0;
     
   
 //Global Ambient Light:   
   GLfloat lmodel_ambient[] = { 1.0, 1.0, 1.0, 1.0};   
   glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient); //override default

   loadImages();
  // cout<<"image loaded"<<endl;
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 
   //Generate the "name" for the texture maps (0):
   glGenTextures(1,texName);
  
  //Bind these parameters to texture 0, the image file:
   glBindTexture(GL_TEXTURE_2D, texName[0]);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
   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, 4, 256, 256, 
                0, GL_RGBA, GL_UNSIGNED_BYTE, myImage256);

   glEnable(GL_LIGHTING);   
   glEnable(GL_LIGHT0);
   glEnable(GL_DEPTH_TEST);
   glEnable(GL_TEXTURE_2D);
}

void normalize(float v[3])
// Makes input vector v have length 1
{
 /* GLfloat d = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
  
  v[0] = v[0]/d;
  v[1] = v[1]/d;
  v[2] = v[2]/d;
*/
}

void drawtriangle(float v1[3], float v2[3], float v3[3])
// Draws the triangle using Line Loop
{
  //  if (wire == true)
  //    glBegin(GL_LINE_LOOP);
  //  else
  glNormal3f(0.0, 0.0, 1.0);
      glBegin(GL_POLYGON);
    glVertex3fv(v1);
    glVertex3fv(v2);
    glVertex3fv(v3);
  glEnd();
}

void subdivide(float v1[3], float v2[3], float v3[3], long depth)
// Recursively subdivides the triangle to given depth
{
  GLfloat v12[3], v23[3], v31[3];
  GLint i;
  
  if (depth == 0)
  {
    drawtriangle(v1, v2, v3);
    return;
  }
  for (i=0; i<3; i++)
  {
    v12[i] = (v1[i]+v2[i])/2.0;
    v23[i] = (v2[i]+v3[i])/2.0;
    v31[i] = (v3[i]+v1[i])/2.0;
  }
  subdivide(v1, v12, v31, depth-1);
  subdivide(v2, v23, v12, depth-1);
  subdivide(v3, v31, v23, depth-1);
  subdivide(v12, v23, v31, depth-1);
}

void drawsurface()
// Draws the square by subdividing into two triangular regions
{
  subdivide(s1, s2, s3, depth);
  subdivide(s3, s4, s1, depth);
}

void image_on_wall()
{
//  glEnable(GL_TEXTURE_2D);
  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  glBindTexture(GL_TEXTURE_2D, texName[0]);
  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(1.0, 1.0, 0.0);
     glTexCoord2f(1.0, 0.0); glVertex3f(-1.0, 1.0, 0.0);
   glEnd();
 // glDisable(GL_TEXTURE_2D);
}


void display(void)
{
   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   //Define the light:
   GLfloat light0_ambient[] = {0.2, 0.2, 0.2, 1.0};
   GLfloat light0_diffuse[] = {diff_red, diff_green, diff_blue, 1.0};
   GLfloat light0_specular[] = {1.0, 1.0, 1.0, 1.0};
   GLfloat light0_position[] = {0.0, 0.0,2.0, 1.0};  //positional
 //  GLfloat spot_direction[] = {0.0, 0.0, -1.0};  //down the neg. z-axis
   
   glLightfv(GL_LIGHT0, GL_AMBIENT, light0_ambient);
   glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_diffuse);
   glLightfv(GL_LIGHT0, GL_SPECULAR, light0_specular);
   glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
//   glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 1.5);
//   glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.5);
//   glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.2);
   
//   glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 15.0);
//   glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, spot_direction);
//   glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 50.0);

 //  if (smooth == true)
     glShadeModel (GL_SMOOTH);
 //  else
 //    glShadeModel (GL_FLAT);
  
 //    if (image)
  //   {
       image_on_wall(); //must call before drawsurface
       drawsurface();
       
  //   }
  //   else
  //     drawsurface();
   
   glutSwapBuffers();
}

void reshape (int w, int h)
{
   glViewport (0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode (GL_PROJECTION);
   glLoadIdentity();
   
   // Orthogonal projection:
   if (w <= h)
      glOrtho (-1.5, 1.5, -1.5*(GLfloat)h/(GLfloat)w,
         1.5*(GLfloat)h/(GLfloat)w, -10.0, 10.0);
   else
      glOrtho (-1.5*(GLfloat)w/(GLfloat)h,
         1.5*(GLfloat)w/(GLfloat)h, -1.5, 1.5, -10.0, 10.0);
         
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
}

void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
      case 'r':
         diff_red = 1.0;  diff_green = 0.0; diff_blue = 0.0;
         glutPostRedisplay();
         break;
      case 'b':
         diff_red = 0.0;  diff_green = 0.0; diff_blue = 1.0;
         glutPostRedisplay();
         break;
      case 'g':
         diff_red = 0.0;  diff_green = 1.0; diff_blue = 0.0;
         glutPostRedisplay();
         break;
      case 'w':
         diff_red = 1.0;  diff_green = 1.0; diff_blue = 1.0;
         glutPostRedisplay();
         break;
      case 'B':
         diff_red = 0.0;  diff_green = 0.0; diff_blue = 0.0;
         glutPostRedisplay();
         break;


      case 'i':  
         image = true;
         glutPostRedisplay();
         break;
      case 'f':
         image = false;
         glutPostRedisplay();
         break;
      case 27:        // ESC key
         exit(0);
         break;
      case 45:        //- key
         depth = depth - 1;
         if (depth < 0)
            depth = 0;
         glutPostRedisplay();
         break;
      case 43:        //+ key
         depth = depth+ 1;
         if (depth > 8)
            depth = 8;
         glutPostRedisplay();
         break;
   }
}
void mykeys(int key, int x, int y)
{
   switch(key){
      case GLUT_KEY_LEFT:
	smooth = false;
	glutPostRedisplay();
	break;
      case GLUT_KEY_RIGHT:
	smooth = true;
	glutPostRedisplay();
	break;
      case GLUT_KEY_DOWN:
	wire = false;
	glutPostRedisplay();
	break;
      case GLUT_KEY_UP:
	wire = true;
	glutPostRedisplay();
	break;
      case GLUT_KEY_HOME:
        wire = true;
        smooth = false;
        depth = 0;
        glutPostRedisplay();
        break;
      default:
	break;
      
    }
}


void loadImages()
{
   int i, j, c;
   ifstream infile;
	 
 //  infile.open("sunrise_256.ppm");
   infile.open("wood_256x256.ppm");
   for (j = 0; j < 256; j++) 
   {
      for (i = 0; i < 256; i++) 
      {
         infile>>c;  myImage256[i][j][0] = (GLubyte) c;
         infile>>c;  myImage256[i][j][1] = (GLubyte) c;
         infile>>c;  myImage256[i][j][2] = (GLubyte) c;
         myImage256[i][j][3] = (GLubyte) 255;
      }
   }
   infile.close();
}