/*
Niniejszy program jest wolnym oprogramowaniem; możesz go
rozprowadzać dalej i / lub modyfikować na warunkach Powszechnej
Licencji Publicznej GNU, wydanej przez Fundację Wolnego
Oprogramowania - według wersji 2 tej Licencji lub(według twojego
wyboru) którejś z późniejszych wersji.

Niniejszy program rozpowszechniany jest z nadzieją, iż będzie on
użyteczny - jednak BEZ JAKIEJKOLWIEK GWARANCJI, nawet domyślnej
gwarancji PRZYDATNOŚCI HANDLOWEJ albo PRZYDATNOŚCI DO OKREŚLONYCH
ZASTOSOWAŃ.W celu uzyskania bliższych informacji sięgnij do
Powszechnej Licencji Publicznej GNU.

Z pewnością wraz z niniejszym programem otrzymałeś też egzemplarz
Powszechnej Licencji Publicznej GNU(GNU General Public License);
jeśli nie - napisz do Free Software Foundation, Inc., 59 Temple
Place, Fifth Floor, Boston, MA  02110 - 1301  USA
*/

#define GLM_FORCE_RADIANS
#define GLM_FORCE_SWIZZLE

#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <stdlib.h>
#include <stdio.h>
#include "constants.h"
#include "allmodels.h"
#include "lodepng.h"
#include "shaderprogram.h"
#include <time.h>

using namespace glm;


GLuint tex1;

GLuint diffTex; //Zmienna reprezentujaca teksturę
GLuint diffTex2; //Zmienna reprezentujaca teksturę

GLuint normalTex; //Zmienna reprezentujaca teksturę
GLuint normalTex2;
GLuint heightTex; //Zmienna reprezentująca teksture
GLuint heightTex2;

float speed_x = 0; // [radiany/s]
float speed_y = 0; // [radiany/s]
float speed = 3.14;
float speed_wah=500;


vec3 pozycja=vec3(0.0f, 0.0f, -11.0f);
float obrot=PI/2;


time_t seconds;



Models::Torus tor1(1.5,0.5,25,25);
Models::Torus tor2(1.5,0.5,25,25);
Models::Cube  cube1;
Models::Torus  torus1;
Models::Torus tor3(0.1,2.0,25,25);
Models::Torus torusik(0.05,0.1,25,25);
Models::Torus torusik2(1.0,0.3,35,35);
Models::Torus kolo1(0.3, 0.1, 20, 20);

float aspect=1; //Stosunek szerokości do wysokości okna

//Uchwyty na shadery
ShaderProgram *shaderProgram; //Wskaźnik na obiekt reprezentujący program cieniujący.


//Kostka

float* vertices_cube=Models::CubeInternal::vertices;
float* normals_cube=Models::CubeInternal::normals;
float* texCoords_cube=Models::CubeInternal::texCoords;
float* c1=Models::CubeInternal::c1;
float* c2=Models::CubeInternal::c2;
float* c3=Models::CubeInternal::c3;
int vertexCount=Models::CubeInternal::vertexCount;

/*

float* vertices_cube=Models::TorusInternal::vertices;
float* normals_cube=Models::TorusInternal::normals;
float* texCoords_cube=Models::TorusInternal::texCoords;
float* c1=Models::TorusInternal::c1;
float* c2=Models::TorusInternal::c2;
float* c3=Models::TorusInternal::c3;
int vertexCount=Models::TorusInternal::vertexCount;
*/

//Czajnik
/*float* vertices=Models::TeapotInternal::vertices;
float* normals=Models::TeapotInternal::vertexNormals;
float* texCoords=Models::TeapotInternal::texCoords;
float* c1=Models::TeapotInternal::c1;
float* c2=Models::TeapotInternal::c2;
float* c3=Models::TeapotInternal::c3;
int vertexCount=Models::TeapotInternal::vertexCount;
*/

vec3 kierunek(float obr,float speed) {
    return speed*vec3(cos(obrot),0,sin(obrot));
}



//Procedura obsługi błędów
void error_callback(int error, const char* description) {
	fputs(description, stderr);
}

//Procedura obsługi klawiatury
void key_callback(GLFWwindow* window, int key,
	int scancode, int action, int mods) {
	if (action == GLFW_PRESS) {
		if (key == GLFW_KEY_LEFT) speed_y = -3.14;
		if (key == GLFW_KEY_RIGHT) speed_y = 3.14;
		if (key == GLFW_KEY_UP) speed_x = -3.14;
		if (key == GLFW_KEY_DOWN) speed_x = 3.14;
        if (key==GLFW_KEY_W) pozycja=pozycja+kierunek(obrot,0.2);
        if (key==GLFW_KEY_S) pozycja=pozycja-kierunek(obrot,0.2);
        if (key==GLFW_KEY_A) pozycja=pozycja-PI/36;
        if (key==GLFW_KEY_D) pozycja=pozycja+PI/36;
	}


	if (action == GLFW_RELEASE) {
		if (key == GLFW_KEY_LEFT) speed_y = 0;
		if (key == GLFW_KEY_RIGHT) speed_y = 0;
		if (key == GLFW_KEY_UP) speed_x = 0;
		if (key == GLFW_KEY_DOWN) speed_x = 0;
	}
}

//Procedura obługi zmiany rozmiaru bufora ramki
void windowResize(GLFWwindow* window, int width, int height) {
    glViewport(0, 0, width, height); //Obraz ma być generowany w oknie o tej rozdzielczości
    if (height!=0) {
        aspect=(float)width/(float)height; //Stosunek szerokości do wysokości okna
    } else {
        aspect=1;
    }
}


GLuint readTexture(char* filename) {
  GLuint tex;
  glActiveTexture(GL_TEXTURE0);

  //Wczytanie do pamięci komputera
  std::vector<unsigned char> image;   //Alokuj wektor do wczytania obrazka
  unsigned width, height;   //Zmienne do których wczytamy wymiary obrazka
  //Wczytaj obrazek
  unsigned error = lodepng::decode(image, width, height, filename);

  //Import do pamięci karty graficznej
  glGenTextures(1,&tex); //Zainicjuj jeden uchwyt
  glBindTexture(GL_TEXTURE_2D, tex); //Uaktywnij uchwyt
  //Wczytaj obrazek do pamięci KG skojarzonej z uchwytem
  glTexImage2D(GL_TEXTURE_2D, 0, 4, width, height, 0,
    GL_RGBA, GL_UNSIGNED_BYTE, (unsigned char*) image.data());

  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_LINEAR);

  return tex;
}

//Procedura inicjująca
void initOpenGLProgram(GLFWwindow* window) {
	//************Tutaj umieszczaj kod, który należy wykonać raz, na początku programu************
	glClearColor(0, 0, 0, 1); //Czyść ekran na czarno
	glEnable(GL_DEPTH_TEST); //Włącz używanie Z-Bufora
	glfwSetKeyCallback(window, key_callback); //Zarejestruj procedurę obsługi klawiatury
	glfwSetFramebufferSizeCallback(window,windowResize); //Zarejestruj procedurę obsługi zmiany rozmiaru bufora ramki

	shaderProgram=new ShaderProgram("vshader.glsl",NULL,"fshader.glsl"); //Wczytaj program cieniujący

	//diffTex=readTexture("bricks2_diffuse.png");
	//normalTex=readTexture("bricks2_normal.png");
    //heightTex=readTexture("bricks2_height.png");
    tex1=readTexture("face4.png");

    diffTex=readTexture("kora_albedo.png");
    diffTex2=readTexture("kora2_albedo.png");
	normalTex=readTexture("kora_normal.png");
	normalTex2=readTexture("metal_normal.png");
    heightTex=readTexture("kora_height.png");
    heightTex2=readTexture("metal2_height.png");
}

//Zwolnienie zasobów zajętych przez program
void freeOpenGLProgram() {
	delete shaderProgram; //Usunięcie programu cieniującego

	glDeleteTextures(1,&diffTex);
	glDeleteTextures(1,&normalTex);
	glDeleteTextures(1,&heightTex);

}

void drawKjub(ShaderProgram *shaderProgram, mat4 mP, mat4 mV, mat4 mM) {
	//Włączenie programu cieniującego, który ma zostać użyty do rysowania
	//W tym programie wystarczyłoby wywołać to raz, w setupShaders, ale chodzi o pokazanie,
	//że mozna zmieniać program cieniujący podczas rysowania jednej sceny
	shaderProgram->use();

	//Przekaż do shadera macierze P,V i M.
	//W linijkach poniżej, polecenie:
	//  shaderProgram->getUniformLocation("P")
	//pobiera numer przypisany zmiennej jednorodnej o podanej nazwie
	//UWAGA! "P" w powyższym poleceniu odpowiada deklaracji "uniform mat4 P;" w vertex shaderze,
	//a mP w glm::value_ptr(mP) odpowiada argumentowi  "mat4 mP;" TYM pliku.
	//Cała poniższa linijka przekazuje do zmiennej jednorodnej P w vertex shaderze dane z argumentu mP niniejszej funkcji
	//Pozostałe polecenia działają podobnie.
	//Poniższe polecenia są z grubsza odpowiednikami glLoadMatrixf ze starego opengla
	glUniformMatrix4fv(shaderProgram->getUniformLocation("P"),1, false, glm::value_ptr(mP));
	glUniformMatrix4fv(shaderProgram->getUniformLocation("V"),1, false, glm::value_ptr(mV));
	glUniformMatrix4fv(shaderProgram->getUniformLocation("M"),1, false, glm::value_ptr(mM));



	glUniform4f(shaderProgram->getUniformLocation("light1"), 0, 0, -8, 1);
    glUniform4f(shaderProgram->getUniformLocation("light2"), 0, 40, 0, 1);


	//Powiąż zmienne typu sampler2D z jednostkami teksturującymi
	glUniform1i(shaderProgram->getUniformLocation("diffuseMap"),0);
	glUniform1i(shaderProgram->getUniformLocation("normalMap"),1);
	glUniform1i(shaderProgram->getUniformLocation("heightMap"),2);

	//Przypisz tekstury do jednostek teksturujących
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D,diffTex);
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D,normalTex);
    glActiveTexture(GL_TEXTURE2);
    glBindTexture(GL_TEXTURE_2D,heightTex);

	//Powiedz OpenGL że podczas rysowania nalezy przesłać dane do atrybutów o numerach wskazanych jako argument.
	//Polecenie shaderProgram->getAttribLocation("vertex") zwraca numer atrybutu o nazwie "vertex".
	//Odpowiada to deklaracji "in vec4 vertex;" w vertex shaderze.
	//Z grubsza odpowiednik polecenia glEnableClientState
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("vertex"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("normal"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("texCoord0"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("c1"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("c2"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("c3"));

    //Wskaż tablicę z której należy pobrać dane do atrybutu o konkretnym numerze.
    //Pierwszym argumentem jest numer przypisany atrybutowi, ostatnim tablica zdanymi.
    //Z grubsza są to odpowiedniki poleceń glVertexPointer,glColorPointer i glNormalPointer ze starego OpenGL
    glVertexAttribPointer(shaderProgram->getAttribLocation("vertex"),4,GL_FLOAT,false,0,vertices_cube);
    glVertexAttribPointer(shaderProgram->getAttribLocation("normal"),4,GL_FLOAT,false,0,normals_cube);
    glVertexAttribPointer(shaderProgram->getAttribLocation("texCoord0"),2,GL_FLOAT,false,0,texCoords_cube);
    glVertexAttribPointer(shaderProgram->getAttribLocation("c1"),4,GL_FLOAT,false,0,c1);
    glVertexAttribPointer(shaderProgram->getAttribLocation("c2"),4,GL_FLOAT,false,0,c2);
    glVertexAttribPointer(shaderProgram->getAttribLocation("c3"),4,GL_FLOAT,false,0,c3);

	//Narysowanie obiektu
	glDrawArrays(GL_TRIANGLES,0,vertexCount);

	//Posprzątanie po sobie
    //Odpowiednik sekwencji poleceń glDisableClientState
	glDisableVertexAttribArray(shaderProgram->getAttribLocation("vertex"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("color"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("normal"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("texCoord0"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("c1"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("c2"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("c3"));
}


void drawKjub2(ShaderProgram *shaderProgram, mat4 mP, mat4 mV, mat4 mM) {
	//Włączenie programu cieniującego, który ma zostać użyty do rysowania
	//W tym programie wystarczyłoby wywołać to raz, w setupShaders, ale chodzi o pokazanie,
	//że mozna zmieniać program cieniujący podczas rysowania jednej sceny
	shaderProgram->use();

	//Przekaż do shadera macierze P,V i M.
	//W linijkach poniżej, polecenie:
	//  shaderProgram->getUniformLocation("P")
	//pobiera numer przypisany zmiennej jednorodnej o podanej nazwie
	//UWAGA! "P" w powyższym poleceniu odpowiada deklaracji "uniform mat4 P;" w vertex shaderze,
	//a mP w glm::value_ptr(mP) odpowiada argumentowi  "mat4 mP;" TYM pliku.
	//Cała poniższa linijka przekazuje do zmiennej jednorodnej P w vertex shaderze dane z argumentu mP niniejszej funkcji
	//Pozostałe polecenia działają podobnie.
	//Poniższe polecenia są z grubsza odpowiednikami glLoadMatrixf ze starego opengla
	glUniformMatrix4fv(shaderProgram->getUniformLocation("P"),1, false, glm::value_ptr(mP));
	glUniformMatrix4fv(shaderProgram->getUniformLocation("V"),1, false, glm::value_ptr(mV));
	glUniformMatrix4fv(shaderProgram->getUniformLocation("M"),1, false, glm::value_ptr(mM));


	glUniform4f(shaderProgram->getUniformLocation("light1"), 0, 0, -8, 1);
    glUniform4f(shaderProgram->getUniformLocation("light2"), 0, 40, 0, 1);

	//Powiąż zmienne typu sampler2D z jednostkami teksturującymi
	glUniform1i(shaderProgram->getUniformLocation("diffuseMap"),0);
	//glUniform1i(shaderProgram->getUniformLocation("normalMap"),1);
	//glUniform1i(shaderProgram->getUniformLocation("heightMap"),2);

	//Przypisz tekstury do jednostek teksturujących
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D,diffTex2);
    //glActiveTexture(GL_TEXTURE1);
   // glBindTexture(GL_TEXTURE_2D,normalTex2);
    //glActiveTexture(GL_TEXTURE2);
    //glBindTexture(GL_TEXTURE_2D,heightTex2);

	//Powiedz OpenGL że podczas rysowania nalezy przesłać dane do atrybutów o numerach wskazanych jako argument.
	//Polecenie shaderProgram->getAttribLocation("vertex") zwraca numer atrybutu o nazwie "vertex".
	//Odpowiada to deklaracji "in vec4 vertex;" w vertex shaderze.
	//Z grubsza odpowiednik polecenia glEnableClientState
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("vertex"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("normal"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("texCoord0"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("c1"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("c2"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("c3"));

    //Wskaż tablicę z której należy pobrać dane do atrybutu o konkretnym numerze.
    //Pierwszym argumentem jest numer przypisany atrybutowi, ostatnim tablica zdanymi.
    //Z grubsza są to odpowiedniki poleceń glVertexPointer,glColorPointer i glNormalPointer ze starego OpenGL
    glVertexAttribPointer(shaderProgram->getAttribLocation("vertex"),4,GL_FLOAT,false,0,vertices_cube);
    glVertexAttribPointer(shaderProgram->getAttribLocation("normal"),4,GL_FLOAT,false,0,normals_cube);
    glVertexAttribPointer(shaderProgram->getAttribLocation("texCoord0"),2,GL_FLOAT,false,0,texCoords_cube);
    glVertexAttribPointer(shaderProgram->getAttribLocation("c1"),4,GL_FLOAT,false,0,c1);
    glVertexAttribPointer(shaderProgram->getAttribLocation("c2"),4,GL_FLOAT,false,0,c2);
    glVertexAttribPointer(shaderProgram->getAttribLocation("c3"),4,GL_FLOAT,false,0,c3);

	//Narysowanie obiektu
	glDrawArrays(GL_TRIANGLES,0,vertexCount);

	//Posprzątanie po sobie
    //Odpowiednik sekwencji poleceń glDisableClientState
	glDisableVertexAttribArray(shaderProgram->getAttribLocation("vertex"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("color"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("normal"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("texCoord0"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("c1"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("c2"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("c3"));
}


void drawKjub3(ShaderProgram *shaderProgram, mat4 mP, mat4 mV, mat4 mM) {
	//Włączenie programu cieniującego, który ma zostać użyty do rysowania
	//W tym programie wystarczyłoby wywołać to raz, w setupShaders, ale chodzi o pokazanie,
	//że mozna zmieniać program cieniujący podczas rysowania jednej sceny
	shaderProgram->use();

	//Przekaż do shadera macierze P,V i M.
	//W linijkach poniżej, polecenie:
	//  shaderProgram->getUniformLocation("P")
	//pobiera numer przypisany zmiennej jednorodnej o podanej nazwie
	//UWAGA! "P" w powyższym poleceniu odpowiada deklaracji "uniform mat4 P;" w vertex shaderze,
	//a mP w glm::value_ptr(mP) odpowiada argumentowi  "mat4 mP;" TYM pliku.
	//Cała poniższa linijka przekazuje do zmiennej jednorodnej P w vertex shaderze dane z argumentu mP niniejszej funkcji
	//Pozostałe polecenia działają podobnie.
	//Poniższe polecenia są z grubsza odpowiednikami glLoadMatrixf ze starego opengla
	glUniformMatrix4fv(shaderProgram->getUniformLocation("P"),1, false, glm::value_ptr(mP));
	glUniformMatrix4fv(shaderProgram->getUniformLocation("V"),1, false, glm::value_ptr(mV));
	glUniformMatrix4fv(shaderProgram->getUniformLocation("M"),1, false, glm::value_ptr(mM));



	glUniform4f(shaderProgram->getUniformLocation("light1"), 0, 0, -8, 1);
    glUniform4f(shaderProgram->getUniformLocation("light2"), 0, 40, 0, 1);


	//Powiąż zmienne typu sampler2D z jednostkami teksturującymi
	glUniform1i(shaderProgram->getUniformLocation("diffuseMap"),0);
	glUniform1i(shaderProgram->getUniformLocation("normalMap"),1);
	glUniform1i(shaderProgram->getUniformLocation("heightMap"),2);

	//Przypisz tekstury do jednostek teksturujących
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D,tex1);
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D,tex1);
    glActiveTexture(GL_TEXTURE2);
    glBindTexture(GL_TEXTURE_2D,tex1);

	//Powiedz OpenGL że podczas rysowania nalezy przesłać dane do atrybutów o numerach wskazanych jako argument.
	//Polecenie shaderProgram->getAttribLocation("vertex") zwraca numer atrybutu o nazwie "vertex".
	//Odpowiada to deklaracji "in vec4 vertex;" w vertex shaderze.
	//Z grubsza odpowiednik polecenia glEnableClientState
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("vertex"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("normal"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("texCoord0"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("c1"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("c2"));
    glEnableVertexAttribArray(shaderProgram->getAttribLocation("c3"));

    //Wskaż tablicę z której należy pobrać dane do atrybutu o konkretnym numerze.
    //Pierwszym argumentem jest numer przypisany atrybutowi, ostatnim tablica zdanymi.
    //Z grubsza są to odpowiedniki poleceń glVertexPointer,glColorPointer i glNormalPointer ze starego OpenGL
    glVertexAttribPointer(shaderProgram->getAttribLocation("vertex"),4,GL_FLOAT,false,0,vertices_cube);
    glVertexAttribPointer(shaderProgram->getAttribLocation("normal"),4,GL_FLOAT,false,0,normals_cube);
    glVertexAttribPointer(shaderProgram->getAttribLocation("texCoord0"),2,GL_FLOAT,false,0,texCoords_cube);
    glVertexAttribPointer(shaderProgram->getAttribLocation("c1"),4,GL_FLOAT,false,0,c1);
    glVertexAttribPointer(shaderProgram->getAttribLocation("c2"),4,GL_FLOAT,false,0,c2);
    glVertexAttribPointer(shaderProgram->getAttribLocation("c3"),4,GL_FLOAT,false,0,c3);

	//Narysowanie obiektu
	glDrawArrays(GL_TRIANGLES,0,vertexCount);

	//Posprzątanie po sobie
    //Odpowiednik sekwencji poleceń glDisableClientState
	glDisableVertexAttribArray(shaderProgram->getAttribLocation("vertex"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("color"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("normal"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("texCoord0"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("c1"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("c2"));
    glDisableVertexAttribArray(shaderProgram->getAttribLocation("c3"));
}




void rysuj_torusiki(mat4 V, mat4 M, float angle)
{

   // mat4 M=mat4(1.0f);


    mat4 M1=translate(M,vec3(2.1f,0,0));
    M1=rotate(M1,angle,vec3(0.0f,0.0f,1.0f));
    glLoadMatrixf(value_ptr(V*M1));
    tor1.drawSolid();


    mat4 M2=translate(M,vec3(-1.1f,0,0));
    M2=rotate(M2,-angle,vec3(0.0f,0.0f,1.0f));
    M2=scale(M2,vec3(0.7f,0.7f,0.7f));
    glLoadMatrixf(value_ptr(V*M2));
    tor2.drawSolid();

    for(int k=0;k< 360;k+=20){

    float kat=((PI*k)/180)+2;
    mat4 K = rotate(M1,kat,vec3(0.0f,0.0f,1.0f));
     K = translate(K,vec3(2.1f,0,0));
     K=scale(K,vec3(0.1f,0.1f,0.1f));
    glLoadMatrixf(value_ptr(V*K));
    cube1.drawSolid();

    }


    for(int k=7;k< 360;k+=20){

    float kat=((PI*k)/180)+2;
    mat4 K = rotate(M2,-kat,vec3(0.0f,0.0f,1.0f));
     K = translate(K,vec3(2.1f,0,0));
     K=scale(K,vec3(0.1f,0.1f,0.1f));
    glLoadMatrixf(value_ptr(V*K));
    cube1.drawSolid();

    }

}

void rysuj_torus(mat4 V, mat4 M,float angle)
{
    mat4 Mtorus=M;
    Mtorus=scale(Mtorus,vec3(1.5f,1.5f,1.5f));
    glLoadMatrixf(value_ptr(V*Mtorus));
    Models::torus.drawSolid();
    /*
    mat4 Mz = M;
   //Mz = translate(Mz, vec3(0.0f, 0.0f, 0.0f));
    //Mz = scale(Mz, vec3(wys/2.0f,szer/2.0f,gleb/2.0f));
    glLoadMatrixf(value_ptr(V*Mz));
    Models::torus.drawSolid();
    */


}


void draw_torus(mat4 V, mat4 M, float a, float b, float c){
    mat4 Mt = M;
    Mt = scale(Mt, vec3(a/2.0f, b/2.0f,c/2.0f));
    glLoadMatrixf(value_ptr(V*Mt));
    glColor3d(0.855,0.647,0.126);
    kolo1.drawSolid();
}




//Procedura rysująca zawartość sceny
void drawScene(GLFWwindow* window, float angle_x, float angle_y, float angle, float angle_zeg, float angle_wah) {
	//************Tutaj umieszczaj kod rysujący obraz******************l

	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); //Wykonaj czyszczenie bufora kolorów i głębokości

	glm::mat4 P = glm::perspective(50 * PI / 180, aspect, 1.0f, 50.0f); //Wylicz macierz rzutowania

	/*glm::mat4 V = glm::lookAt( //Wylicz macierz widoku
		glm::vec3(0.0f, 0.0f, -11.0f),
		glm::vec3(0.0f, 0.0f, 0.0f),
		glm::vec3(0.0f, 1.0f, 0.0f));
		*/

	        glm::mat4 V = glm::lookAt( //Wylicz macierz widoku
                  pozycja,
                  pozycja+kierunek(obrot,1),
                  vec3(0.0f,1.0f,0.0f));



	//Wylicz macierz modelu rysowanego obiektu
	glm::mat4 M = glm::mat4(1.0f);
	M = glm::rotate(M, angle_x, glm::vec3(1, 0, 0));
	M = glm::rotate(M, angle_y, glm::vec3(0, 1, 0));


    //mat4 M1=M;
    //M1=translate(M,vec3(2.1f,0,0));
    //M1=rotate(M1,angle,vec3(0.0f,0.0f,1.0f));
    //glLoadMatrixf(value_ptr(V*M1));
    //tor1.drawSolid();

    //mat4 Mws1=M;
   // glLoadMatrixf(value_ptr(V*Mws1));
    //Models::cube.drawSolid();




//drawKjub2(shaderProgram,P,V,M);



	//Narysuj obiekt

//////////////głowa zegara//////////////
	drawKjub(shaderProgram,P,V,M);




//////////////prawa scianka//////////////
    mat4 Mp1=M;
    //M1=scale(M1,vec3(5.0f,5.0f,5.0f));
    Mp1=scale(Mp1, vec3(-0.1f, 1.5f, 1.0f));
    //M1 = glm::rotate(M, (angle/4), glm::vec3(0, 1, 0));
    Mp1=translate(Mp1,vec3(9.0f,-1.65f,0.0f));
    //M1=scale(M,vec3(1.0f,1.0f,0.5f));
    drawKjub(shaderProgram, P, V, Mp1);



//////////////lewa scianka//////////////
    mat4 Mp2=M;
    //M1=scale(M1,vec3(5.0f,5.0f,5.0f));
    Mp2=scale(Mp2, vec3(-0.1f, 1.5f, 1.0f));
    //M1 = glm::rotate(M, (angle/4), glm::vec3(0, 1, 0));
    Mp2=translate(Mp2,vec3(-9.0f,-1.65f,0.0f));
    //M1=scale(M,vec3(1.0f,1.0f,0.5f));
   drawKjub(shaderProgram, P, V, Mp2);


//////////////tylnia scianka//////////////
    mat4 Mp3=M;
    //M1=scale(M1,vec3(5.0f,5.0f,5.0f));
    Mp3=scale(Mp3, vec3(1.0f, 1.5f, -0.1f));
    //M1 = glm::rotate(M, (angle/4), glm::vec3(0, 1, 0));
    Mp3=translate(Mp3,vec3(0.0f,-1.65f,-9.0f));
    //M1=scale(M,vec3(1.0f,1.0f,0.5f));
   drawKjub(shaderProgram, P, V, Mp3);


//////////////tarcza//////////////

    //mat4 Mtar=M;
    //Mtar=scale(Mtar, vec3(0.5f, 0.3f, 0.4f));
    //Mtar=translate(M,vec3(0.0f,-1.65f,5.0f));
    //glLoadMatrixf(value_ptr(V*Mtar));
    //torusik2.drawSolid();


    mat4 M1=M;
   // M1=rotate(M1,angle,vec3(0.0f,0.0f,1.0f));
    M1=translate(M1,vec3(0.0f,0.0f,5.0f));
    glLoadMatrixf(value_ptr(V*M1));
    //draw_torus(V,M1,2.0f,2.0f,2.0f);





    //mat4 M1=translate(M,vec3(2.0f,1.5f,2.0f));
    //M1= scale(M1, vec3(0.05f,0.05f,0.05f));
    //M1=rotate(M1,angle,vec3(0.0f,0.0f,1.0f));
    //glLoadMatrixf(value_ptr(V*M1));
    //mat4 Mtor=M;
    //Mtor=scale(Mtor, vec3(0.1f, 0.1f, 0.1f));
    //torusik2.drawSolid();




//////////////male cos na srodku tarczy//////////////

    mat4 Mcos=M;
    //M1=scale(M1,vec3(5.0f,5.0f,5.0f));
    Mcos=scale(M, vec3(0.03f, 0.03f, -0.03f));
    //M1 = glm::rotate(M, (angle/4), glm::vec3(0, 1, 0));
    Mcos=translate(Mcos,vec3(0.0f,0.0f,35.0f));
    //M1=scale(M,vec3(1.0f,1.0f,0.5f));
 //  drawKjub2(shaderProgram, P, V, Mcos);









//////////////wskazowka minuty//////////////


 //  mat4 Mwsk1=Mcos;
   /*
    for(int k=0; k<=360; k=k+6)
    {
        float kat=((kat*5)/kat);
        //float kat = (GLfloat)glfwGetTime()
        Mwsk1 = rotate(Mcos, angle, vec3(0.0f,0.0f,1.0f));
	Mwsk1=translate(Mwsk1,vec3(0.0f,15.0f,0.0f));
        Mwsk1=scale(Mwsk1, vec3(1.0f, 10.0f, 1.0f));
        drawKjub2(shaderProgram, P, V, Mwsk1);
    } */

/*
    Mwsk1 = rotate(Mcos, angle_zeg, vec3(0.0f,0.0f,1.0f));
	Mwsk1=translate(Mwsk1,vec3(0.0f,15.0f,0.0f));
        Mwsk1=scale(Mwsk1, vec3(1.0f, 10.0f, 1.0f));
        drawKjub2(shaderProgram, P, V, Mwsk1);
*/





//tarcza zegara z teksturka
mat4 Mcos2=M;
Mcos2=translate(Mcos2, vec3(0.0f,0.0f,-1.0f));
Mcos2=scale(Mcos2,vec3(1.0f,1.0f,0.01));
glLoadMatrixf(value_ptr(V*Mcos2));
drawKjub3(shaderProgram, P, V, Mcos2);





        //wskazówka minutowa
        Mcos2=M;
        Mcos2=translate(Mcos2, vec3 (-0.0f,1.0f,-0.918f));
        Mcos2=rotate(Mcos2,angle_zeg,vec3(0,0,1)); // tutaj zmieniamy kąt wychylenia wahadła

        mat4 Mniewiem=Mcos2;
        Mniewiem=translate(Mniewiem, vec3 (0.0f,0.2f,0.0f));
        Mniewiem=scale(Mniewiem, vec3(0.01,0.18,0.01));
        glLoadMatrixf(value_ptr(V*Mniewiem));
        //drawKjub(shaderProgram, P, V, Mniewiem);


//////////////wskazowka godziny//////////////

    mat4 Mwsk2=Mcos;
    //M1=scale(M1,vec3(5.0f,5.0f,5.0f));

        Mwsk2 = rotate(Mcos,angle/144,vec3(0.0f,0.0f,1.0f));
        Mwsk2=translate(Mwsk2,vec3(0.0f,15.0f,0.0f));
        Mwsk2=scale(Mwsk2, vec3(1.0f, 10.0f, 1.0f));

    drawKjub2(shaderProgram, P, V, Mwsk2);


//////////////wskazowka minutowa2//////////////



    mat4 Mwsk3=Mcos;
    //M1=scale(M1,vec3(5.0f,5.0f,5.0f));

        Mwsk3 = rotate(Mcos,angle/12,vec3(0.0f,0.0f,1.0f));
        Mwsk3=translate(Mwsk3,vec3(0.0f,16.0f,0.0f));
        Mwsk3=scale(Mwsk3, vec3(1.0f, 11.0f, 1.0f));

    drawKjub2(shaderProgram, P, V, Mwsk3);



//////////////wahadlo//////////////

    mat4 Mwah=Mcos;
    //M1=scale(M1,vec3(5.0f,5.0f,5.0f));

        //Mwsk3 = rotate(Mcos,angle/12,vec3(0.0f,0.0f,1.0f));
        Mwah=rotate(Mwah,angle_wah,vec3(0.0f,0.0f,1.0f));
        Mwah=translate(Mwah,vec3(0.0f,-58.0f,-20.0f));
        Mwah=scale(Mwah, vec3(1.0f, 25.0f, 1.0f));
         //Mwah=rotate(Mwah,angle_wah,vec3(0,0,1));

    drawKjub2(shaderProgram, P, V, Mwah);



    mat4 Mtor=M;
    Mtor=translate(M,vec3(-0.7f,-1.5f,1.0f));
    Mtor=scale(Mtor, vec3(0.15f,0.15f,0.15f));
   // rysuj_torusiki(V,Mtor,angle);


    //mój torus_próba
//    mat4 M1=translate(M,vec3(2.1f,0,0));
  //  M1=rotate(M1,angle,vec3(0.0f,0.0f,1.0f));
    //glLoadMatrixf(value_ptr(V*M1));
   // drawTorus(shaderProgram, P, V, M);



	//Przerzuć tylny bufor na przedni
	glfwSwapBuffers(window);


}



int main(void)
{
	GLFWwindow* window; //Wskaźnik na obiekt reprezentujący okno

	glfwSetErrorCallback(error_callback);//Zarejestruj procedurę obsługi błędów

	if (!glfwInit()) { //Zainicjuj bibliotekę GLFW
		fprintf(stderr, "Nie można zainicjować GLFW.\n");
		exit(EXIT_FAILURE);
	}

	window = glfwCreateWindow(500, 500, "OpenGL", NULL, NULL);  //Utwórz okno 500x500 o tytule "OpenGL" i kontekst OpenGL.

	if (!window) //Jeżeli okna nie udało się utworzyć, to zamknij program
	{
		fprintf(stderr, "Nie można utworzyć okna.\n");
		glfwTerminate();
		exit(EXIT_FAILURE);
	}

	glfwMakeContextCurrent(window); //Od tego momentu kontekst okna staje się aktywny i polecenia OpenGL będą dotyczyć właśnie jego.
	glfwSwapInterval(1); //Czekaj na 1 powrót plamki przed pokazaniem ukrytego bufora

	if (glewInit() != GLEW_OK) { //Zainicjuj bibliotekę GLEW
		fprintf(stderr, "Nie można zainicjować GLEW.\n");
		exit(EXIT_FAILURE);
	}

	initOpenGLProgram(window); //Operacje inicjujące

	float angle = 0;
	float angle_x = 0; //Kąt obrotu obiektu
	float angle_y = 0; //Kąt obrotu obiektu
	float angle_zeg=0.0f; //kat do wskazowek
	float angle_wah=0.0f;
	int lewo=1;
	int pom=0.01;

	glfwSetTime(0); //Wyzeruj licznik czasu

	//Główna pętla
	while (!glfwWindowShouldClose(window)) //Tak długo jak okno nie powinno zostać zamknięte
	{
	    angle += speed*glfwGetTime();
		angle_x += speed_x*glfwGetTime(); //Zwiększ kąt o prędkość kątową razy czas jaki upłynął od poprzedniej klatki
		angle_y += speed_y*glfwGetTime(); //Zwiększ kąt o prędkość kątową razy czas jaki upłynął od poprzedniej klatki
		glfwSetTime(0); //Wyzeruj licznik czasu
        pom=pom+0.01;


        //angle_wah+=speed*1000000*glfwGetTime();

        //angle_wah+=speed*sin(20*glfwGetTime())*((3.14)/4);

        //angle_wah=(angle_wah)+100*lewo*sin(100*glfwGetTime())*((3.14)/4);
        angle_wah+=10000*speed*lewo*glfwGetTime();
        if (angle_wah>=0.3)
        {lewo=-1;
            //angle_wah=(angle_wah)+100*lewo*sin(100*glfwGetTime())*((3.14)/4);
            angle_wah+=10000*speed*lewo*glfwGetTime();
        }
        else if (angle_wah<=-0.3)
        {lewo=1;
        //angle_wah=(angle_wah)+100*lewo*sin(1000*glfwGetTime())*((3.14)/4);
        angle_wah+=10000*speed*lewo*glfwGetTime();
        }
        //angle_wah=(angle_wah)+lewo*speed_wah*glfwGetTime(); //left decyduje czy prawo czy lewo

		drawScene(window,angle_x,angle_y,angle,angle_zeg, angle_wah); //Wykonaj procedurę rysującą
		glfwPollEvents(); //Wykonaj procedury callback w zalezności od zdarzeń jakie zaszły.
	}

	freeOpenGLProgram();

	glfwDestroyWindow(window); //Usuń kontekst OpenGL i okno
	glfwTerminate(); //Zwolnij zasoby zajęte przez GLFW
	exit(EXIT_SUCCESS);
}