#include <GLee.h>
#include <GL/glfw.h>
#include <stdio.h>
#include "include2.h"
#include <IL/il.h>
#include <IL/ilut.h>
GLuint shaderProgram;
GLuint shaderProgram2=NULL;
float demofloat=1;
GLfloat position[] = { 0, 0, 0  , 1.0f };

GLint               axa;
GLint               textureUnit0; // The texture map
GLint               textureUnit1; // The normal  map
GLint               invRadius; // The normal  map
GLint               heightScale; // The normal  map

float musta_dem=1;

void musta(int a){
glEnable(GL_BLEND);
glEnable(GL_ALPHA_TEST); //Enable alpha-blending
glAlphaFunc(GL_GREATER, 0.01f);

//glDisable(GL_DEPTH_TEST);
  glUseProgram(shaderProgram2);
  glDisable(GL_LIGHTING);
glPushMatrix();
glTranslatef(0,0,-100.01);
if(a==1)
    musta_dem-=0.01;
if(a==2)
    musta_dem+=0.01;
glColor4f(0,0,0,musta_dem);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, NULL);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, NULL);
//glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glBegin( GL_QUADS );
glTexCoord2d(0.0,0.0); glVertex2d(-120.0,-90.0);
glTexCoord2d(1.0,0.0); glVertex2d(120.0,-90.0);
glTexCoord2d(1.0,1.0); glVertex2d(120.0,90.0);
glTexCoord2d(0.0,1.0); glVertex2d(-120.0,90.0);
glEnd();
glPopMatrix();
  glEnable(GL_LIGHTING);
  glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);
glColor4f(1,1,1,1);
}

void printShaderInfoLog(GLuint obj)
{
    int size = 0;
    char *log;

    glGetShaderiv(obj, GL_INFO_LOG_LENGTH, &size);

    if (size > 0)
    {
        log = new char[size];
        glGetShaderInfoLog(obj, size, NULL, log);
        printf(log);
    }


}
void initShaders()
{
freopen( "CON", "wt", stdout );
freopen( "CON", "wt", stderr );
    GLcharARB * my_fragment_shader_source;
	GLcharARB * my_vertex_shader_source;

	// Get Vertex And Fragment Shader Sources
	FILE *fp;
	GLubyte *buf;
	int length;
	bool ret = true;

	if (!(fp = fopen("vertexshader_offset.glsl","rb")))
		printf("Error opening shader.");

	fseek(fp, 0, SEEK_END);
	length = ftell(fp);
	fseek(fp, 0, SEEK_SET);

	my_vertex_shader_source = new GLcharARB[length+1];
	fread( my_vertex_shader_source, 1, length, fp);

	if (!(fp = fopen("fragmentshader_offset.glsl","rb")))
		fprintf(stderr,"Error opening shader.");

	fseek(fp, 0, SEEK_END);
	length = ftell(fp);
	fseek(fp, 0, SEEK_SET);

	my_fragment_shader_source = new GLcharARB[length+1];
	fread( my_fragment_shader_source, 1, length, fp);


    GLuint vertexShader;
    GLuint fragmentShader;
    const GLchar *fragmentCode;
    const GLchar *vertexCode;

    fragmentCode = my_fragment_shader_source;
    vertexCode = my_vertex_shader_source;

    //Luodaan shader objektit
    fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    vertexShader = glCreateShader(GL_VERTEX_SHADER);

    glShaderSource(fragmentShader, 1, &fragmentCode, NULL);
    glShaderSource(vertexShader, 1, &vertexCode, NULL);

    //Käännetään shaderit
    glCompileShader(fragmentShader);
    glCompileShader(vertexShader);



    //Tulostetaan käännöstiedot
    printShaderInfoLog(fragmentShader);
    printShaderInfoLog(vertexShader);

    //Luodaan ja linkataan shader ohjelma
    shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, fragmentShader);
    glAttachShader(shaderProgram, vertexShader);
    glLinkProgram(shaderProgram);


    //Asetetaan ohjelma käyttöön
    glUseProgram(shaderProgram);

        int size = 0;
    char *log;
glGetProgramiv(shaderProgram, GL_INFO_LOG_LENGTH, &size);

    if (size > 0)
    {
        log = new char[size];
        glGetProgramInfoLog(shaderProgram, size, NULL, log);
        printf(log);
        delete [] log;
    }


}


void e1(){
glFogf(GL_FOG_DENSITY, 0.0036 );
  glUseProgram(shaderProgram);
  //glUniform1f(axa, sin(demofloat*3.14/180)*0.15);

    glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(0, 0, -600);
    glRotatef(demofloat*0.1, 0, 1, 0);
    glCallList(o1list);

    glPopMatrix();

    glEnable(GL_BLEND);
glEnable(GL_ALPHA_TEST); //Enable alpha-blending
glAlphaFunc(GL_GREATER, 0.1f);

glDisable(GL_DEPTH_TEST);
  glUseProgram(shaderProgram2);
  glDisable(GL_LIGHTING);
glPushMatrix();
glTranslatef(0,0,-200.1);
glColor3f(1,1,1);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[6]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, NULL);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glBegin( GL_QUADS );
glTexCoord2d(0.0,0.0); glVertex2d(-90.0,-60.0);
glTexCoord2d(1.0,0.0); glVertex2d(90.0,-60.0);
glTexCoord2d(1.0,1.0); glVertex2d(90.0,60.0);
glTexCoord2d(0.0,1.0); glVertex2d(-90.0,60.0);
glEnd();
glPopMatrix();
  glEnable(GL_LIGHTING);
  glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);

}



void e2(){
glFogf(GL_FOG_DENSITY, 0.002 );
  glUseProgram(shaderProgram);
  //glUniform1f(axa, sin(demofloat*3.14/180)*0.15);

    glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(-demofloat*0.5, 0, -100);
    glCallList(o2list);

    glPopMatrix();

}


void e3(){
glFogf(GL_FOG_DENSITY, 0.002 );
  glUseProgram(shaderProgram);
  //glUniform1f(axa, sin(demofloat*3.14/180)*0.15);

    glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(0, -demofloat*0.5, -500);
    glCallList(o4list);

    glPopMatrix();

}



void e4(){

glFogf(GL_FOG_DENSITY, 0.002 );
  glUseProgram(shaderProgram);
  //glUniform1f(axa, sin(demofloat*3.14/180)*0.15);

    glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(0, 0, demofloat*0.5);
    glCallList(o6list);

    glPopMatrix();

}

void e5(){
 glMateriali(GL_FRONT, GL_SHININESS, 10);
glFogf(GL_FOG_DENSITY, 0.0015 );
  glUseProgram(shaderProgram);
  //glUniform1f(axa, sin(demofloat*3.14/180)*0.15);

    glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(-200-demofloat*0.7, 0, -600);
    glCallList(o5list);

    glPopMatrix();
glMateriali(GL_FRONT, GL_SHININESS, 120);


}


void e6(){

glFogf(GL_FOG_DENSITY, 0.003 );
  glUseProgram(shaderProgram);
  //glUniform1f(axa, sin(demofloat*3.14/180)*0.15);

          glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(0, 0, -600);
    glRotatef(-demofloat*0.1, 0, 1, 1);
    glScalef(1.8 , 1.8, 1.8);
    glCallList(o3list);

    glPopMatrix();

    glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(0, 0, -600);
    glRotatef(demofloat*0.1, 1, 1, 1);
    glCallList(o3list);

    glPopMatrix();

        glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(0, 0, -600);
    glRotatef(-demofloat*0.2, 1, 1, 1);
    glScalef(0.7, 0.7, 0.7);
    glCallList(o3list);

    glPopMatrix();


       glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(0, 0, -600);
    glRotatef(-demofloat*0.3, 1, 1, 0);
    glScalef(0.4, 0.4, 0.4);
    glCallList(o3list);

    glPopMatrix();

           glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[4]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[5]);

    glTranslatef(0, 0, -600);
    glRotatef(-demofloat*0.1, 1, 1, 1);
    glScalef(1, 1, 1);
    glCallList(o7list);

    glPopMatrix();
}

int main()
{
    int     width, height;
    int     frame = 0;
    bool    running = true;

    glfwInit();


    if( !glfwOpenWindow( 1280, 720, 0, 0, 0, 0, 24, 0, GLFW_FULLSCREEN ) )
    {
        glfwTerminate();
        return 0;
    }
glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4);
       glfwGetWindowSize( &width, &height );
        height = height > 0 ? height : 1;

            glViewport( 0, 0, width, height );

        glClearColor( 1, 1, 1, 1 );
        glClear( GL_COLOR_BUFFER_BIT );

        glMatrixMode( GL_PROJECTION );
        glLoadIdentity();
        gluPerspective( 65.0f, (GLfloat)width/(GLfloat)height, 100.0f, 10000.0f );

        // Draw some rotating garbage


glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
//glDepthMask(GL_TRUE);
//glDepthFunc(GL_LEQUAL);

  float Cl[4]={1,1 ,1,1};
  float A[4]={1,1,1 ,1};
  float Cd[4]={1,1, 1,1};


  //GLfloat position[] = { 0, 200, 0  , 1.0f };
 //GLfloat position[] = { 0, 0, 0  , 1.0f };
  glLightfv(GL_LIGHT0, GL_POSITION, position);
  glLightfv(GL_LIGHT0, GL_DIFFUSE, Cl);
  glLightfv(GL_LIGHT0, GL_AMBIENT, A);
  GLfloat specular[] = {1, 0.9, 0.8, 1.0};
  GLfloat specReflection[] = {0.8 , 0.6, 0.4, 1};
  glLightfv(GL_LIGHT0, GL_SPECULAR, specular);


   glMaterialfv(GL_FRONT, GL_DIFFUSE, Cd);

 glMaterialfv(GL_FRONT, GL_SPECULAR, specReflection);
  glMateriali(GL_FRONT, GL_SHININESS, 120);
  //glMateriali(GL_FRONT, GL_SHININESS, 10);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);



ilInit();
iluInit();
ilutRenderer(ILUT_OPENGL);

TextureArray[1] = ilutGLLoadImage("1.PNG");
TextureArray[2] = ilutGLLoadImage("1n.PNG");
TextureArray[3] = ilutGLLoadImage("peitto.PNG");
TextureArray[4] = ilutGLLoadImage("lava.PNG");
TextureArray[5] = ilutGLLoadImage("lavan.PNG");
TextureArray[6] = ilutGLLoadImage("mrp.PNG");

initShaders();
LoadObj(o1, "1.OBJ");
o1list=Gen3DObjectList(o1);
LoadObj(o2, "2.OBJ");
o2list=Gen3DObjectList(o2);
LoadObj(o3, "3.OBJ");
o3list=Gen3DObjectList(o3);
LoadObj(o4, "4.OBJ");
o4list=Gen3DObjectList(o4);
LoadObj(o5, "5.OBJ");
o5list=Gen3DObjectList(o5);
LoadObj(o6, "6.OBJ");
o6list=Gen3DObjectList(o6);
LoadObj(o7, "7.OBJ");
o7list=Gen3DObjectList(o7);

glEnable(GL_FOG);
float FogCol[3]={1, 1, 1};
glFogfv(GL_FOG_COLOR,FogCol);
glFogf(GL_FOG_DENSITY, 0.0038f);
//glFogf(GL_FOG_DENSITY, 0);
 glFogf(GL_FOG_START, -900.f);

    textureUnit0 = glGetUniformLocation(shaderProgram, "colorMap"); // The texture map
	textureUnit1 = glGetUniformLocation(shaderProgram, "normalMap"); // The normal map
    axa = glGetUniformLocation(shaderProgram, "axa");

    glUniform1i(textureUnit0, 0); // Specify that our texture (called "colourMap" in the shader, is on texture unit 0)
    glUniform1i(textureUnit1, 1);
    srand ( time(NULL) );

    int da=0;

  inittime=glfwGetTime();
  helppoheikki=GetTickCount();

mciSendString("play ms.mp3", NULL, 0, 0);

    while(running)
    {
    char buffer[20] = {};
    sprintf(buffer, "%i", Get_FPS());
    glfwSetWindowTitle(buffer);

  capFrameRate(60);
        frame++;
  glMatrixMode( GL_MODELVIEW );
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();

currentTime=glfwGetTime()-inittime;

demofloat+=1;


if(currentTime>0 && currentTime<0.1){
demofloat=0;
}
 if(currentTime>0 && currentTime<20){
e1();
}


if(currentTime>20 && currentTime<20.1){
demofloat=0;
}
 if(currentTime>20 && currentTime<40){
e2();
}


if(currentTime>40 && currentTime<40.1){
demofloat=0;
}
 if(currentTime>40 && currentTime<60){
e3();
}


if(currentTime>60 && currentTime<60.1){
demofloat=0;
}
 if(currentTime>60 && currentTime<90){
e4();
}


if(currentTime>90 && currentTime<90.1){
demofloat=0;
}
 if(currentTime>90 && currentTime<120){
e5();
}


if(currentTime>120 && currentTime<120.1){
demofloat=0;
}
 if(currentTime>120 && currentTime<150){
e6();
}


 if(currentTime>150){
break;
}




//glFogf(GL_FOG_DENSITY, 0.0036 );
//  glUseProgram(shaderProgram);
//  //glUniform1f(axa, sin(demofloat*3.14/180)*0.15);
//
//    glPushMatrix();
//    glActiveTexture(GL_TEXTURE0);
//    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
//	glActiveTexture(GL_TEXTURE1);
//	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);
//
//    glTranslatef(0, 0, -600);
//    glRotatef(demofloat*0.1, 0, 1, 0);
//    glCallList(o1list);
//
//    glPopMatrix();
//
//    glEnable(GL_BLEND);
//glEnable(GL_ALPHA_TEST); //Enable alpha-blending
//glAlphaFunc(GL_GREATER, 0.1f);
//
//glDisable(GL_DEPTH_TEST);
//  glUseProgram(shaderProgram2);
//  glDisable(GL_LIGHTING);
//glPushMatrix();
//glTranslatef(0,0,-200.1);
//glColor3f(1,1,1);
//    glActiveTexture(GL_TEXTURE0);
//    glBindTexture(GL_TEXTURE_2D, TextureArray[6]);
//	glActiveTexture(GL_TEXTURE1);
//	 glBindTexture(GL_TEXTURE_2D, NULL);
//glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
//glBegin( GL_QUADS );
//glTexCoord2d(0.0,0.0); glVertex2d(-90.0,-60.0);
//glTexCoord2d(1.0,0.0); glVertex2d(90.0,-60.0);
//glTexCoord2d(1.0,1.0); glVertex2d(90.0,60.0);
//glTexCoord2d(0.0,1.0); glVertex2d(-90.0,60.0);
//glEnd();
//glPopMatrix();
//  glEnable(GL_LIGHTING);
//  glDisable(GL_BLEND);
//glEnable(GL_DEPTH_TEST);
//glDisable(GL_ALPHA_TEST);


/*
glFogf(GL_FOG_DENSITY, 0.002 );
  glUseProgram(shaderProgram);
  //glUniform1f(axa, sin(demofloat*3.14/180)*0.15);

    glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(-demofloat*0.5, 0, -100);
    glCallList(o2list);

    glPopMatrix();
*/

/*
glFogf(GL_FOG_DENSITY, 0.003 );
  glUseProgram(shaderProgram);
  //glUniform1f(axa, sin(demofloat*3.14/180)*0.15);

          glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(0, 0, -600);
    glRotatef(-demofloat*0.1, 0, 1, 1);
    glScalef(1.8 , 1.8, 1.8);
    glCallList(o3list);

    glPopMatrix();

    glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(0, 0, -600);
    glRotatef(demofloat*0.1, 1, 1, 1);
    glCallList(o3list);

    glPopMatrix();

        glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(0, 0, -600);
    glRotatef(-demofloat*0.2, 1, 1, 1);
    glScalef(0.7, 0.7, 0.7);
    glCallList(o3list);

    glPopMatrix();


       glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(0, 0, -600);
    glRotatef(-demofloat*0.3, 1, 1, 0);
    glScalef(0.4, 0.4, 0.4);
    glCallList(o3list);

    glPopMatrix();

           glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[4]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[5]);

    glTranslatef(0, 0, -600);
    glRotatef(-demofloat*0.1, 1, 1, 1);
    glScalef(1, 1, 1);
    glCallList(o7list);

    glPopMatrix();
*/
/*
glFogf(GL_FOG_DENSITY, 0.002 );
  glUseProgram(shaderProgram);
  //glUniform1f(axa, sin(demofloat*3.14/180)*0.15);

    glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(0, -demofloat*0.5, -500);
    glCallList(o4list);

    glPopMatrix();
*/
/*
 glMateriali(GL_FRONT, GL_SHININESS, 10);
glFogf(GL_FOG_DENSITY, 0.0015 );
  glUseProgram(shaderProgram);
  //glUniform1f(axa, sin(demofloat*3.14/180)*0.15);

    glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(-200-demofloat*0.7, 0, -600);
    glCallList(o5list);

    glPopMatrix();
glMateriali(GL_FRONT, GL_SHININESS, 120);
*/
/*
glFogf(GL_FOG_DENSITY, 0.002 );
  glUseProgram(shaderProgram);
  //glUniform1f(axa, sin(demofloat*3.14/180)*0.15);

    glPushMatrix();
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[1]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, TextureArray[2]);

    glTranslatef(0, 0, demofloat*0.5);
    glCallList(o6list);

    glPopMatrix();
*/





glEnable(GL_BLEND);
glEnable(GL_ALPHA_TEST); //Enable alpha-blending
glAlphaFunc(GL_GREATER, 0.1f);

glDisable(GL_DEPTH_TEST);
  glUseProgram(shaderProgram2);
  glDisable(GL_LIGHTING);
glPushMatrix();
glTranslatef(0,0,-100.1);
glColor3f(1,1,1);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, TextureArray[3]);
	glActiveTexture(GL_TEXTURE1);
	 glBindTexture(GL_TEXTURE_2D, NULL);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glBegin( GL_QUADS );
glTexCoord2d(0.0,0.0); glVertex2d(-120.0,-90.0);
glTexCoord2d(1.0,0.0); glVertex2d(120.0,-90.0);
glTexCoord2d(1.0,1.0); glVertex2d(120.0,90.0);
glTexCoord2d(0.0,1.0); glVertex2d(-120.0,90.0);
glEnd();
glPopMatrix();
  glEnable(GL_LIGHTING);
  glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);



if(currentTime>0 && currentTime<6){
    musta(1);
}
if(currentTime>14 && currentTime<20){
    musta(2);
}


if(currentTime>20 && currentTime<26){
    musta(1);
}
if(currentTime>34 && currentTime<40){
    musta(2);
}


if(currentTime>40 && currentTime<46){
    musta(1);
}
if(currentTime>54 && currentTime<60){
    musta(2);
}


if(currentTime>60 && currentTime<66){
    musta(1);
}
if(currentTime>84 && currentTime<90){
    musta(2);
}



if(currentTime>90 && currentTime<96){
    musta(1);
}
if(currentTime>114 && currentTime<120){
    musta(2);
}


if(currentTime>120 && currentTime<126){
    musta(1);
}
if(currentTime>144 && currentTime<150){
    musta(2);
}








 glfwSwapBuffers();

        // exit if ESC was pressed or window was closed
        running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam( GLFW_OPENED);
    }

    glfwTerminate();

    return 0;
}

