#include "coursecity.h"


coursecity::coursecity() {
  //cout<<"creating coursecity"<<endl;
  coursefile = NULL;
  coursemap = NULL;
}

coursecity::~coursecity() {
  //cout<<"deleting the coursecity"<<endl;
  if (coursefile) delete[] coursefile;
  if (coursemap) delete [] coursemap;
}


bool coursecity::Init(char *coursefilei) {
  int numtexturestoread;

  playerlist=new (PlayerState *)[25];//only 25 allowed
  for (int x=0; x<25; x++) playerlist[x]=NULL;

  //cout<<"initing coursecity"<<endl;
  SetupModels();

  coursefile=new char[256];
  strcpy(coursefile,coursefilei);
  ifstream is(coursefile);
  if (!is.good()) {
    cerr<<"Cannot open coursefile "<<coursefile<<endl;
    return false;
  }
  is>>coursewidth;
  is>>courseheight;


  is>>numtexturestoread;



  //load the textures
  cout<<"loading course textures"<<endl;
  texturesread=0;//how many were actually read
  char *nexttexture=new char[256];
    while (is.good() && (texturesread<numtexturestoread) ) {
      is>>nexttexture;
      cout<<"going to load texture: "<<nexttexture<<endl;
      
      TextureMap &tex = CourseTexture[texturesread];

      if (tex.LoadTIFF(nexttexture)) {
      // set up params and bind name
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        tex.InitTextureParams(false);//or after the clamps?
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
      } else cerr<<"Error loading course texture "<<texturesread<<endl;
      texturesread++;
    }
  cout<<"finished loading textures: "<<texturesread<<endl;
  delete [] nexttexture;


  //get the starting points
  is>>start1x>>start1y>>start1z>>start1theta>>start2x>>start2y>>start2z>>start2theta;
  cout<<"read the starts as "<<start1x<<","<<start1y<<","<<start1z<<","<<start1theta<<","<<start2x<<","<<start2y<<","<<start2z<<","<<start2theta<<endl;


  //load the tile type definitions
  //read in data to interpret the tiletypes here?
  char clearline[512];
  is>>clearline;
  is>>numtypes;
  is>>clearline;
  tiletypes=new tileinfo[256];//can potentially use any char, not just the usual ones

  for (int x=0; x<256; x++) tiletypes[x].id=0;

  int heightint=0;
  int idindex=0;
  char inchar;
  for (int x=0; x<numtypes; x++) {
    is>>inchar;
    idindex=(int)inchar;
    tiletypes[idindex].id=inchar;
    is>>tiletypes[idindex].solid>>heightint>>tiletypes[idindex].modelid>>tiletypes[idindex].xsize>>tiletypes[idindex].ysize;
    tiletypes[idindex].height=((float)heightint)/10.0;
  }

  cout<<"tiletypes read as:"<<endl;
  for (int x=0; x<256; x++) {
    idindex=(int)(tiletypes[x].id);
    if (idindex==0) {
      cout<<"null"<<endl;
    } else {
    cout<<tiletypes[idindex].id<<"=index "<<(int)(tiletypes[idindex].id)<<","<<tiletypes[idindex].solid<<","<<tiletypes[idindex].modelid<<","<<tiletypes[idindex].xsize<<","<<tiletypes[idindex].ysize<<endl;
    }
  }

  is>>clearline;
  cout<<clearline<<endl;;

  coursemap=new (tiledata)[coursewidth*courseheight];

  //read in the map
  //for (int x=0; x<coursewidth*courseheight; x++) {
  for (int y=0; y<courseheight; y++) 
    for (int x=0; x<coursewidth; x++) {
      if (!is.good()) {
        cerr<<"Error reading course file: map at y,x:"<<y<<","<<x<<endl;
        //return false;
      }
      is>>coursemap[(courseheight-1-y)*coursewidth+x].type;
      //coursemap[x].rendered=false;
      coursemap[(courseheight-1-y)*coursewidth+x].contents=-1;
    }

  for (int x=0; x<courseheight; x++) {
    for (int y=0; y<coursewidth; y++) {
      if (x<50)
      cout<<coursemap[(courseheight-1-x)*coursewidth+y].type;
    }
    if (x<50)
    cout<<endl;
  }





  SetSolid();
  /*
  // for (int x=0; x<courseheight; x++) {
  for (int x=0; x<courseheight; x++) {
    for (int y=0; y<coursewidth; y++) {
      cout<<coursemap[x*coursewidth+y].solid;
    }
    cout<<endl;
  }
  */


  return true;
}






/////////////


//x,y,z is the center of the dynamic object
//zthreshold is the distance between the center and the bottom of the object
//radius is the xy plane radius the object takes up. diagonals count-if the radius is 1, it covers a 1x1 unit square, not a circle 
//returns true for a collision, false for no collision
/*
bool coursecity::CheckCollision(float x, float y, float z, float radius, float zthreshold) {

  if ((coursemap[(int)y*coursewidth+(int)x].solid)&&(coursemap[(int)y*coursewidth+(int)x].height>=z-zthreshold))
    return true;
  /  *
  if (coursemap[(int)(y+radius)*coursewidth+(int)(x+radius)].height>=z-zthreshold) 
    return true;
  if (coursemap[(int)(y-radius)*coursewidth+(int)(x-radius)].height>=z-zthreshold) 
    return true;
  if (coursemap[(int)(y+radius)*coursewidth+(int)(x+radius)].height>=z-zthreshold) 
    return true;
  if (coursemap[(int)(y-radius)*coursewidth+(int)(x-radius)].height>=z-zthreshold) 
    return true;
    *  /

  return false;
}
*/


//when testing a single square, not a path, it ignores occupants of the tile
bool coursecity::CheckCollision(float foldx, float foldy, float oldz, float fnewx, float fnewy, float newz, int thisguy) {
  int oldx=(int)foldx;
  int oldy=(int)foldy;
  int newx=(int)fnewx;
  int newy=(int)fnewy;
  if ((oldx<0)||(oldy<0)||(newx<0)||(newy<0)) return true;//off course
  if ((oldx>=coursewidth)||(newx>=coursewidth)||(oldy>=courseheight)||(newy>=courseheight)) {
    //cout<<"collision by off course"<<endl;
    return true;//off course
  }

  //new way: points with radii of 1
  for (int y=-1+newy; y<2+newy; y++) {//check the 9 squares around the target
    for (int x=-1+newx; x<2+newx; x++) {
      
      if ((x<0)||(x>=coursewidth)||(y<0)||(y>=courseheight)) {
        //cout<<"collision by edge of course"<<endl;
        return true;//too close to the edge of the course
      }
      
      
      if (coursemap[y*coursewidth+x].solid) 
        if (coursemap[y*coursewidth+x].height>=newz-1.0) {
          return true;//tile is solid, youre not above the block
        }

      if (coursemap[y*coursewidth+x].contents!=-1)
        if (coursemap[y*coursewidth+x].contents!=thisguy) { 
          //if (distance between the two is <1.01) { no need to take the sqrt, since if it's <=1 itll get smaller, if >1 bigger, about 1 is our cutoff
            if ( ((thenpcs->chars[coursemap[y*coursewidth+x].contents].loc.x-fnewx)*(thenpcs->chars[coursemap[y*coursewidth+x].contents].loc.x-fnewx) + (thenpcs->chars[coursemap[y*coursewidth+x].contents].loc.y-fnewy)*(thenpcs->chars[coursemap[y*coursewidth+x].contents].loc.y-fnewy))<1.01 ) {
              //cout<<"collision by too close to object "<<coursemap[y*coursewidth+x].contents<<" thisguy="<<thisguy<<endl;
              return true;//someone else is too near
            }
          
          if ((newx==x)&&(newy==y)) return true;//tile is occupied by someone else
        }

      if ((thisguy>=10000)&&(coursemap[y*coursewidth+x].contents>=10000)&&(coursemap[y*coursewidth+x].contents!=thisguy)) {
        float play2x=playerlist[coursemap[y*coursewidth+x].contents-10000]->loc.x;
        float play2y=playerlist[coursemap[y*coursewidth+x].contents-10000]->loc.y;
        if ( ((fnewx-play2x)*(fnewx-play2x)+(fnewy-play2y)*(fnewy-play2y))<1.0) {
          return true;//players are colliding with each other
        }
      }
      

      if ((thisguy<10000)&&(coursemap[y*coursewidth+x].contents>=10000)) {
        return true; //close to the player. npc's stop when very near the players
      }

      if ((thisguy<10000)&&(coursemap[y*coursewidth+x].contents>=10000)) {
        if (playerlist[coursemap[y*coursewidth+x].contents-10000]!=NULL) {
          float playx=playerlist[coursemap[y*coursewidth+x].contents-10000]->loc.x;
          float playy=playerlist[coursemap[y*coursewidth+x].contents-10000]->loc.y;
          if ( ((playx-fnewx)*(playx-fnewx) + (playy-fnewy)*(playy-fnewy))<1.0) {
            return true;
          }
        }
      }
    }
      
  }
  //if we get here, we checked all 9 tiles around the target tile, and nothing is blocking the way.

  /*
  //old way: replace
  //if we're moving within the same tile, make sure we're not stuck
  if ((oldx==newx) && (oldy==newy)) {
    if (coursemap[newy*coursewidth+newx].solid) {
      if (coursemap[newy*coursewidth+newx].height>=newz-1.0) 
        return true;//tile is solid, youre not above the block
    }
    if (coursemap[newy*coursewidth+newx].contents!=-1)
      if (coursemap[newy*coursewidth+newx].contents!=thisguy)
        return true;//tile is occupied
    return false;
  }


  //is it adjacent?
  if ((abs(newx-oldx)>1)||(abs(newy-oldy)>1))
    return true;//collision by bad input, old/new tiles too far away
  //is there a path?
  if (coursemap[newy*coursewidth+newx].contents!=-1)
    return true;//new tile is occupied
  if (coursemap[newy*coursewidth+newx].solid) {
    if (coursemap[newy*coursewidth+newx].height>=newz-1.0) 
      return true;//new tile is solid, youre not above the block
  }
  //check adjacents for diagonal. ignore npcs blocking diagonally, only check walls
  if ((newx-oldx!=0)&&(newy-oldy!=0)) {
    if ( ((coursemap[oldy*coursewidth+newx].solid==true)&&(coursemap[oldy*coursewidth+newx].height>=newz-1.0))  &&  ((coursemap[newy*coursewidth+oldx].solid==true)&&(coursemap[newy*coursewidth+oldx].height>=newz-1.0)) )
      return true;//both sides are blocked
  }
  */
  //cout<<"no collision"<<endl;
  if ((newx==7)&&(newy==13)) cout<<"ERROR 7,13 reached false"<<endl;
  return false;//theres a path
}






bool coursecity::AddDynamicObject(int x, int y, int objectid) {
  if (coursemap[y*coursewidth+x].contents!=-1) {
    cerr<<"error adding object: "<<objectid<<" at "<<x<<","<<y<<". If you're trying to add a new player, its start location is blocked by an object."<<endl;
    return false;
  }
  coursemap[y*coursewidth+x].contents=objectid;
  return true;
}
bool coursecity::RemoveDynamicObject(int x, int y) {
  if (coursemap[y*coursewidth+x].contents==-1) return false;
  coursemap[y*coursewidth+x].contents=-1;
  return true;
}

bool coursecity::MoveDynamicObject(int oldx, int oldy, int newx, int newy) {
  if (coursemap[oldy*coursewidth+oldx].contents==-1)
    return false;//no source object
  if (coursemap[newy*coursewidth+newx].contents!=-1)
    return false;//destination is full
  coursemap[newy*coursewidth+newx].contents=coursemap[oldy*coursewidth+oldx].contents;
  coursemap[oldy*coursewidth+oldx].contents=-1;
  return true;
};






int coursecity::GetSize() {
  if (coursewidth>=courseheight)
    return coursewidth;
  else return courseheight;
}


void coursecity::SetStartLocation(PlayerState *theplayer,int which, bool init) {
  playerlist[which]=theplayer;

  if (which%2==0) {
    (*theplayer).loc.x=(float)start1x+0.05;//add this to prevent rounding error
    //floats at x.00 vs. x.99 could get confused, and the course could lose track of where the object is. the same thing is done for npc's
    (*theplayer).loc.y=(float)start1y+0.05;
    (*theplayer).loc.z=start1z;
    (*theplayer).theta=start1theta;
    (*theplayer).phi=90;
    if(init) AddDynamicObject((int)start1x,(int)start1y,10000);
  } else {
    (*theplayer).loc.x=(float)start2x+0.05;
    (*theplayer).loc.y=(float)start2y+0.05;
    (*theplayer).loc.z=start2z;
    (*theplayer).theta=start2theta;
    (*theplayer).phi=90;
    if(init) AddDynamicObject((int)start2x,(int)start2y,10001);
  }
}






void coursecity::Skybox(int hour, int minute) {
  glEnable(GL_TEXTURE_2D);
  glDisable(GL_DEPTH_TEST);
  glDepthMask(GL_FALSE);
  glMatrixMode(GL_MODELVIEW);


  // load camera transformation matrix
  GLfloat modelview[16];
  glPushMatrix();
  glGetFloatv(GL_MODELVIEW_MATRIX, modelview);

  // zero the translation part 
  modelview[12] = 0.0;
  modelview[13] = 0.0;
  modelview[14] = 0.0;
  glLoadMatrixf(modelview);

  glClearColor(1,1,1,1);
  
  //glLoadIdentity();
  glColor3f(0,1,0);//debug color-shouldnt actually show up
  //adjust colors depending on the time of day
  if ((hour>7)&&(hour<17)) {//day
    glColor3f(1,1,1);
  } else if ((hour<4)||(hour>20)) {//night
    glColor3f(0.1,0.05,0.2);
  } else {//transition
    if (hour==4) {
      glColor3f(0.2+((float)minute/60.0)/5.0,0.1,0.4);
    } else if (hour==5) {
      glColor3f(0.4+((float)minute/60.0)/2.5,0.1+((float)minute/60.0)/3.333,0.4);
    } else if (hour==6) {
      glColor3f(0.8+((float)minute/60.0)/5.0,0.4+((float)minute/60.0)/2.5,0.4+((float)minute/60.0)/5.0);
    } else if (hour==7) {
      glColor3f(1.0,0.8+((float)minute/60.0)/5.0,0.6+((float)minute/60.0)/2.5);
    } 

    else if (hour==20) {
      glColor3f(0.4-((float)minute/60.0)/5.0,0.1,0.4);
    } else if (hour==19) {
      glColor3f(0.8-((float)minute/60.0)/2.5,0.4-((float)minute/60.0)/3.333,0.4);
    } else if (hour==18) {
      glColor3f(1.0-((float)minute/60.0)/5.0,0.8-((float)minute/60.0)/2.5,0.6-((float)minute/60.0)/5.0);
    } else if (hour==17) {
      glColor3f(1.0,1.0-((float)minute/60.0)/5.0,1.0-((float)minute/60.0)/2.5);
    }
  }

  //cout<<"up texture name: "<<CourseTexture[SKYBOX_UP].GetName()<<endl;
  glBindTexture(GL_TEXTURE_2D, CourseTexture[SKYBOX_UP].GetName());
  // draw the quad
  glBegin(GL_QUADS);
  glTexCoord2i(0,1);//01,11,10,00
  glVertex3f(-sbx, -sby, sbz);
  glTexCoord2i(1,1);
  glVertex3f(sbx, -sby, sbz);
  glTexCoord2i(1,0);
  glVertex3f(sbx, sby, sbz);
  glTexCoord2i(0,0);
  glVertex3f(-sbx, sby, sbz);
  glEnd();

  // make the texture we want active
  glBindTexture(GL_TEXTURE_2D, CourseTexture[SKYBOX_BACK].GetName());

  // draw the quad
  glBegin(GL_QUADS);
  glTexCoord2i(0,0);//00,10,11,01
  glVertex3f(-sbx, -sby, -sbz);
  glTexCoord2i(1,0);
  glVertex3f(-sbx, sby, -sbz);
  glTexCoord2i(1,1);
  glVertex3f(-sbx, sby, sbz);
  glTexCoord2i(0,1);
  glVertex3f(-sbx, -sby, sbz);
  glEnd();

  // make the texture we want active
  glBindTexture(GL_TEXTURE_2D, CourseTexture[SKYBOX_LEFT].GetName());

  // draw the quad
  glBegin(GL_QUADS);
  glTexCoord2i(1,0);//10,00,01,11
  glVertex3f(-sbx, -sby, -sbz);
  glTexCoord2i(0,0);
  glVertex3f(sbx, -sby, -sbz);
  glTexCoord2i(0,1);
  glVertex3f(sbx, -sby, sbz);
  glTexCoord2i(1,1);
  glVertex3f(-sbx, -sby, sbz);
  glEnd();

  // make the texture we want active
  glBindTexture(GL_TEXTURE_2D, CourseTexture[SKYBOX_RIGHT].GetName());

  // draw the quad
  glBegin(GL_QUADS);
  glTexCoord2i(0, 0);//00,10,11,01
  glVertex3f(-sbx, sby, -sbz);
  glTexCoord2i(1,0);
  glVertex3f(sbx, sby, -sbz);
  glTexCoord2i(1,1);
  glVertex3f(sbx, sby, sbz);
  glTexCoord2i(0,1);
  glVertex3f(-sbx, sby, sbz);
  glEnd();
  
  // make the texture we want active
  glBindTexture(GL_TEXTURE_2D, CourseTexture[SKYBOX_FRONT].GetName());
  // draw the quad
  glBegin(GL_QUADS);
  glTexCoord2i(1,0);//10,00,01,11
  glVertex3f(sbx, -sby, -sbz);
  glTexCoord2i(0,0);
  glVertex3f(sbx, sby, -sbz);
  glTexCoord2i(0,1);
  glVertex3f(sbx, sby, sbz);
  //glColor3f(1,0,1);
  glTexCoord2i(1,1);
  glVertex3f(sbx, -sby, sbz);
  glEnd();
  


  // make the texture we want active//down
  glBindTexture(GL_TEXTURE_2D, CourseTexture[SKYBOX_DOWN].GetName());
  // draw the quad
  glBegin(GL_QUADS);
  glTexCoord2i(0, 0);
  glVertex3f(-sbx, -sby, -sbz);
  glTexCoord2i(1, 0);
  glVertex3f(sbx, -sby, -sbz);
  glTexCoord2i(1, 1);
  glVertex3f(sbx, sby, -sbz);
  glTexCoord2i(0, 1);
  glVertex3f(-sbx, sby, -sbz);
  glEnd(); 



  glPopMatrix();

  glDisable(GL_TEXTURE_2D);
  glEnable(GL_DEPTH_TEST);
  glDepthMask(GL_TRUE);
}









bool coursecity::Render() {
  //cout<<"worldcity is rendering"<<endl;
  //positioning stuff that will eventually be handled by camera
  /*
  glPushMatrix();//matches the one at the end of render
  glLoadIdentity();
  gluPerspective(65,1,0.1,1000);//fov, aspect,near,farclip
  gluLookAt(0,0,10, 10,0,-1, 0,0,1);
  */
  //end camera stuff
    //cout<<"rendering course"<<endl;
  MainLight(0);
  Skybox(12,0);
  MainLight(1);

  SetGlowLights(1);


  //cout<<"skybox done"<<endl;
  glPushMatrix();//done in camera calls, watch out for matching
  glClearColor(0,0,0,1);
  glEnable(GL_TEXTURE_2D);


  //



  //draw the terrain
  for (int row=0; row<courseheight; row++) {
    for (int col=0; col<coursewidth; col++) {
      //cout<<":"<<row*coursewidth+col;
      DrawTile(row,col,0,tiletypes[coursemap[row*coursewidth+col].type].modelid);
    }
  }
  //cout<<"done with 4"<<endl;
  /*glBegin(GL_QUADS);
  glColor3f(1,0,0);
  glVertex3f(-10,-10,-1);
  glColor3f(0,1,0);
  glVertex3f(-10,10,-1);
  glColor3f(0,0,1);
  glVertex3f(10,10,-1);
  glColor3f(1,0,1);
  glVertex3f(10,-10,-1);
  glEnd();*/
  /*
  glBegin(GL_QUADS);
  glColor3f(1,1,0);
  glVertex3f(-10,-10,1);
  glColor3f(1,0,0);
  glVertex3f(-10,10,1);
  glColor3f(0,1,1);
  glVertex3f(10,10,1);
  glColor3f(1,1,0.3);
  glVertex3f(10,-10,1);
  glEnd();*/

  //glColor3f(1,1,1);

  SetGlowLights(0);
  MainLight(0);
  glDisable(GL_TEXTURE_2D);
  glPopMatrix();//matches the one in the camera class
  return true;
}






//set up the general ambient light-the sun, basically
void coursecity::MainLight(int on) {
  glShadeModel(GL_SMOOTH);
  if (on) {
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    //glEnable(GL_LIGHT1);

    GLfloat position0[]={0,1,0,1};
    GLfloat position1[]={0,0,1,1};
    GLfloat ambient0[]={1,1,1,1.0};
    GLfloat ambient1[]={0.8,0.8,0.8,1.0};
    GLfloat diffuse0[]={0.9,0.9,0.9,1.0};//was 0.7's
    GLfloat globalambient[]={1,1,1,1.0};

    glPushMatrix();
    glLoadIdentity();
    glLightfv(GL_LIGHT0,GL_POSITION,position0);
    glLightfv(GL_LIGHT0,GL_AMBIENT,ambient0);  //was disabled 
    glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuse0);    
    glPopMatrix();
    glPushMatrix();
    glLoadIdentity();
    glLightfv(GL_LIGHT1,GL_POSITION,position1);
    glLightfv(GL_LIGHT1,GL_AMBIENT,ambient1);  //was disabled 
    glLightfv(GL_LIGHT1,GL_DIFFUSE,diffuse0);    
    glPopMatrix();

    //glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);

    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalambient);

  } else {
    GLfloat globalambientoff[]={0.2,0.2,0.2,1.0};
    //glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE);
    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, globalambientoff);
    glDisable(GL_LIGHT0);
    glDisable(GL_LIGHT1);
    glDisable(GL_LIGHTING);
  }
}



//set up the general ambient light-the sun, basically
void coursecity::SetGlowLights(int on) {
  glShadeModel(GL_SMOOTH);
  if (on) {
    //glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE);

    glEnable(GL_LIGHTING);
    if (playerlist[0]->glowing>=0) {
    glEnable(GL_LIGHT2);

    //GLfloat position2[]={0,1,0,1};
    GLfloat position2[]={playerlist[0]->loc.x,playerlist[0]->loc.y,playerlist[0]->loc.z};
    GLfloat ambient2[]={1,1,0,1.0};
    GLfloat diffuse2[]={1,1,0.1,1.0};
    GLfloat specular2[]={1,1,0.1,1.0};

    glLightf(GL_LIGHT2,GL_QUADRATIC_ATTENUATION,0.08);

    glPushMatrix();
    //glLoadIdentity();
    glLightfv(GL_LIGHT2,GL_POSITION,position2);
    glLightfv(GL_LIGHT2,GL_AMBIENT,ambient2);  //was disabled 
    glLightfv(GL_LIGHT2,GL_DIFFUSE,diffuse2);    
    glLightfv(GL_LIGHT2,GL_DIFFUSE,specular2);    
    glPopMatrix();
    }


    if (playerlist[1]!=NULL) 
    if (playerlist[1]->glowing>=0) {
    glEnable(GL_LIGHT3);

    //GLfloat position3[]={0,1,0,1};
    GLfloat position3[]={playerlist[1]->loc.x,playerlist[1]->loc.y,playerlist[1]->loc.z};
    GLfloat ambient3[]={1,1,0,1.0};
    GLfloat diffuse3[]={1,1,0.1,1.0};
    GLfloat specular3[]={1,1,0.1,1.0};

    glLightf(GL_LIGHT3,GL_QUADRATIC_ATTENUATION,0.08);

    glPushMatrix();
    //glLoadIdentity();
    glLightfv(GL_LIGHT3,GL_POSITION,position3);
    glLightfv(GL_LIGHT3,GL_AMBIENT,ambient3);  //was disabled 
    glLightfv(GL_LIGHT3,GL_DIFFUSE,diffuse3);       
    glLightfv(GL_LIGHT2,GL_DIFFUSE,specular3); 
    glPopMatrix();
    }

  } else {
    glDisable(GL_LIGHT2);
    glDisable(GL_LIGHT3);
    glDisable(GL_LIGHTING);
  }
}