#include <windows.h>
#include <iostream>
#include <fstream>
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <stdlib.h>
#include "biblioteka.h"
using namespace std;

static int slices = 16;
static int stacks = 16;

//wklejone

GLfloat PI = 3.14;
GLfloat alfa = -PI/2;
GLfloat skok_point = 300.0f; //odl punktu osberwowoanego
GLfloat skok_eye = 10.0f; //do pozycji oka
GLfloat eyex = 0; //x,y oka
GLfloat eyey = 0;
GLfloat eyez = -1;
GLfloat pointx = skok_point * cos(alfa);
GLfloat pointy = 0.0;
GLfloat pointz = skok_point * sin(alfa);
float k=0;
GLPVector3 vPoints[3]=
{
{0.0f, -1.0f, 0.0f},
{1.0f, -1.0f, 0.0f},
{0.0f, -1.0f, -1.0f}
};
GLPMatrix Macierz_cieni;
const GLfloat light_ambient[] = { 0.0f, 0.0f, 0.0f, 1.0f };
const GLfloat light_diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat light_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
GLfloat light_position[] = { 2.0f, 5.0f, 5.0f, 0.0f };
GLPVector4 vLightPos={2.0f, 5.0f, 5.0f, 0.0f};
const GLfloat mat_ambient[] = { 0.7f, 0.7f, 0.7f, 1.0f };
const GLfloat mat_diffuse[] = { 0.8f, 0.8f, 0.8f, 1.0f };
const GLfloat mat_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat high_shininess[] = { 100.0f };
//wyklejone

/* GLUT callback Handlers */

#define LICZBA_OB_TEXTUR 3
GLuint obiektyTextur [LICZBA_OB_TEXTUR];
char *plikiTextur[LICZBA_OB_TEXTUR] = {"C:\\Users\\Szymon\\Desktop\\tekturyRAF\\wood.tga", "C:\\Users\\Szymon\\Desktop\\tekturyRAF\\sky_night.tga", "C:\\Users\\Szymon\\Desktop\\tekturyRAF\\Lilie.tga"};

int lWez, lEle;
double **Wez;
int **Ele;

int lWez2, lEle2;//do wczytywania obiektu zmienne liczba wezlow i liczba elementow
double **Wez2;//tablice do wczytywania zmiennych obiektu
int **Ele2;

int lWez3, lEle3;//do wczytywania obiektu zmienne liczba wezlow i liczba elementow
double **Wez3;//tablice do wczytywania zmiennych obiektu
int **Ele3;

int lWez4, lEle4;//do wczytywania obiektu zmienne liczba wezlow i liczba elementow
double **Wez4;//tablice do wczytywania zmiennych obiektu
int **Ele4;

//wyklejone
static void resize(int width, int height)
{
    const float ar = (float) width / (float) height;

    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(-ar, ar, -1.0, 1.0, 2.0, 400.0);
    //glOrtho(-8,8,-8,8,-8,8);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity() ;
}
float difamb[]={1.0, 0.5, 0.3,1.0};
static void display(void)
{
    const double t = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
    const double a = t*90.0;

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glColor3d(1,1,1);
    glPushMatrix();
        glTranslated(0,15,-50);
        glRotatef(-80,1,0,0);
        glBindTexture (GL_TEXTURE_2D, obiektyTextur[2]);
        glBegin(GL_TRIANGLES);
        for(int nrEl=0;nrEl<lEle;nrEl++)
        {
            glNormal3f(0.0f, 0.0f, 1.0f);
            glTexCoord2f(0.0f, 0.0f);
            glVertex3f(Wez[Ele[nrEl][0]][0],Wez[Ele[nrEl][0]][1], Wez[Ele[nrEl][0]][2]);
            glTexCoord2f(1.0f, 0.0f);
            glVertex3f(Wez[Ele[nrEl][1]][0],Wez[Ele[nrEl][1]][1], Wez[Ele[nrEl][1]][2]);
            glTexCoord2f(1.0f, 1.0f);
            glVertex3f(Wez[Ele[nrEl][2]][0],Wez[Ele[nrEl][2]][1], Wez[Ele[nrEl][2]][2]);
        }
        glEnd();
    glPopMatrix();

    glPushMatrix();
        glTranslated(10,15,-50);
        glRotatef(-80,1,0,0);
        glBindTexture (GL_TEXTURE_2D, obiektyTextur[2]);
        glBegin(GL_TRIANGLES);
        for(int nrEl2=0;nrEl2<lEle2;nrEl2++)
        {
            glNormal3f(0.0f, 0.0f, 1.0f);
            glTexCoord2f(0.0f, 0.0f);
            glVertex3f(Wez2[Ele2[nrEl2][0]][0],Wez2[Ele2[nrEl2][0]][1], Wez2[Ele2[nrEl2][0]][2]);
            glTexCoord2f(1.0f, 0.0f);
            glVertex3f(Wez2[Ele2[nrEl2][1]][0],Wez2[Ele2[nrEl2][1]][1], Wez2[Ele2[nrEl2][1]][2]);
            glTexCoord2f(1.0f, 1.0f);
            glVertex3f(Wez2[Ele2[nrEl2][2]][0],Wez2[Ele2[nrEl2][2]][1], Wez2[Ele2[nrEl2][2]][2]);
        }
        glEnd();
    glPopMatrix();

    glPushMatrix();
        glTranslated(0,0,-60);
        glRotatef(-80,1,0,0);
        glBindTexture (GL_TEXTURE_2D, obiektyTextur[1]);
        glBegin(GL_TRIANGLES);
        for(int nrEl3=0;nrEl3<lEle3;nrEl3++)
        {
            glNormal3f(0.0f, 0.0f, 1.0f);
            glTexCoord2f(0.0f, 0.0f);
            glVertex3f(Wez3[Ele3[nrEl3][0]][0],Wez3[Ele3[nrEl3][0]][1], Wez3[Ele3[nrEl3][0]][2]);
            glTexCoord2f(1.0f, 0.0f);
            glVertex3f(Wez3[Ele3[nrEl3][1]][0],Wez3[Ele3[nrEl3][1]][1], Wez3[Ele3[nrEl3][1]][2]);
            glTexCoord2f(1.0f, 1.0f);
            glVertex3f(Wez3[Ele3[nrEl3][2]][0],Wez3[Ele3[nrEl3][2]][1], Wez3[Ele3[nrEl3][2]][2]);
        }
        glEnd();
    glPopMatrix();

    glPushMatrix();
        glTranslated(5,15,-50);
        glRotatef(-80,1,0,0);
        glBindTexture (GL_TEXTURE_2D, obiektyTextur[2]);
        glBegin(GL_TRIANGLES);
        for(int nrEl4=0;nrEl4<lEle4;nrEl4++)
        {
            glNormal3f(0.0f, 0.0f, 1.0f);
            glTexCoord2f(0.0f, 0.0f);
            glVertex3f(Wez4[Ele4[nrEl4][0]][0],Wez4[Ele4[nrEl4][0]][1], Wez4[Ele4[nrEl4][0]][2]);
            glTexCoord2f(1.0f, 0.0f);
            glVertex3f(Wez4[Ele4[nrEl4][1]][0],Wez4[Ele4[nrEl4][1]][1], Wez4[Ele4[nrEl4][1]][2]);
            glTexCoord2f(1.0f, 1.0f);
            glVertex3f(Wez4[Ele4[nrEl4][2]][0],Wez4[Ele4[nrEl4][2]][1], Wez4[Ele4[nrEl4][2]][2]);
        }
        glEnd();
    glPopMatrix();

        glPushMatrix();
glTranslated(0,-5,-10);
glRotated(10,1,0,0);
glBindTexture (GL_TEXTURE_2D, obiektyTextur[1]);
 glBegin(GL_QUADS);

               glColor3d(1,1,1);

                glTexCoord2f(0, 1);
                glVertex3d(60,0,-60);
                glTexCoord2f(1, 1);
                glVertex3d(60,0,60);
                glTexCoord2f(1, 0);
                glVertex3d(-60,0,60);
                glTexCoord2f(0, 0);
                glVertex3d(-60,0,-60);

                glColor3d(0,0,0);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glPushMatrix();
glTranslated(0,0,0);
glMultMatrixf(Macierz_cieni);
glutSolidTeapot(1);
//glutSolidTorus(1.0, 2.0, 2, 50);
glPopMatrix();
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);


glEnd();
glPopMatrix();

    glutSwapBuffers();
}


static void key(unsigned char key, int x, int y)
{
    switch (key)
    {
        case 27 :
case 'q':
exit(0);
break;

case '+':
slices++;
stacks++;
break;
case 'o':
light_position[1]-=0.1;
vLightPos[1]-=0.1;
glpMakeShadowMatrix(vPoints, vLightPos, Macierz_cieni);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
break;
case 'p':
light_position[1]+=0.1;
vLightPos[1]+=0.1;
glpMakeShadowMatrix(vPoints, vLightPos, Macierz_cieni);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
break;

case '-':
if (slices>3 && stacks>3)
{
slices--;
stacks--;
}
break;
    }

    glutPostRedisplay();
}

static void idle(void)
{
    glutPostRedisplay();
}

void wczytajPlik(char *nazwaPliku,char*nazwaPliku2,char*nazwaPliku3,char*nazwaPliku4){
    ifstream plik(nazwaPliku);
    int pom1, pom2;
    plik>>lWez;
    Wez = new double* [lWez];

    for(int i=0; i<lWez; i++)
        Wez[i]=new double[3];

    for(int i=0;i<lWez;i++)
        plik>>pom1>>Wez[i][0]>>Wez[i][1]>>Wez[i][2];
    plik>>lEle;

    Ele = new int* [lEle];

    for(int i=0; i<lEle; i++)
        Ele[i]=new int[3];

    for(int i=0; i<lEle;i++){
        plik>>pom1>>pom1>>pom1>>pom1>>pom1>>Ele[i][0]>>Ele[i][1]>>Ele[i][2];
        Ele[i][0]--;
        Ele[i][1]--;
        Ele[i][2]--;
    }

    cout<<"Liczba wezlow, liczba elementow: "<<lWez<<"\t"<<lEle<<endl;
    plik.close();
    //koniec 1 obiektu
    ifstream plik2(nazwaPliku2);
    int pom1x,pom2y;
     plik2>>lWez2;
    Wez2 = new double* [lWez2];

    for(int i=0; i<lWez2; i++)
        Wez2[i]=new double[3];

    for(int i=0;i<lWez2;i++)
        plik2>>pom1x>>Wez2[i][0]>>Wez2[i][1]>>Wez2[i][2];
    plik2>>lEle2;

    Ele2 = new int* [lEle2];

    for(int i=0; i<lEle2; i++)
        Ele2[i]=new int[3];

    for(int i=0; i<lEle2;i++){
        plik2>>pom1x>>pom1x>>pom1x>>pom1x>>pom1x>>Ele2[i][0]>>Ele2[i][1]>>Ele2[i][2];
        Ele2[i][0]--;
        Ele2[i][1]--;
        Ele2[i][2]--;
    }

    cout<<"Liczba wezlow, liczba elementow: "<<lWez2<<"\t"<<lEle2<<"\n";
    plik2.close();

     //koniec 2 obiektu
    ifstream plik3(nazwaPliku3);
    int pom1x1,pom2y1;
     plik3>>lWez3;
    Wez3 = new double* [lWez3];

    for(int i=0; i<lWez3; i++)
        Wez3[i]=new double[3];

    for(int i=0;i<lWez3;i++)
        plik3>>pom1x1>>Wez3[i][0]>>Wez3[i][1]>>Wez3[i][2];
    plik3>>lEle3;

    Ele3 = new int* [lEle3];

    for(int i=0; i<lEle3; i++)
        Ele3[i]=new int[3];

    for(int i=0; i<lEle3;i++){
        plik3>>pom1x1>>pom1x1>>pom1x1>>pom1x1>>pom1x1>>Ele3[i][0]>>Ele3[i][1]>>Ele3[i][2];
        Ele3[i][0]--;
        Ele3[i][1]--;
        Ele3[i][2]--;
    }

    cout<<"Liczba wezlow, liczba elementow: "<<lWez3<<"\t"<<lEle3<<"\n";
    plik3.close();
     //koniec 3 obiektu


     // 4 obiekt
    ifstream plik4(nazwaPliku4);
    int pom1x11,pom2y11;
     plik4>>lWez4;
    Wez4 = new double* [lWez4];

    for(int i=0; i<lWez4; i++)
        Wez4[i]=new double[3];

    for(int i=0;i<lWez4;i++)
        plik4>>pom1x11>>Wez4[i][0]>>Wez4[i][1]>>Wez4[i][2];
    plik4>>lEle4;

    Ele4 = new int* [lEle4];

    for(int i=0; i<lEle4; i++)
        Ele4[i]=new int[3];

    for(int i=0; i<lEle4;i++){
        plik4>>pom1x11>>pom1x11>>pom1x11>>pom1x11>>pom1x11>>Ele4[i][0]>>Ele4[i][1]>>Ele4[i][2];
        Ele4[i][0]--;
        Ele4[i][1]--;
        Ele4[i][2]--;
    }

    cout<<"Liczba wezlow, liczba elementow: "<<lWez4<<"\t"<<lEle4;
    plik4.close();
     //koniec 4 obiektu
}



/* Program entry point */

int main(int argc, char *argv[])
{
    glutInit(&argc, argv);
    glutInitWindowSize(840,600);
    glutInitWindowPosition(10,10);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

    wczytajPlik("C:\\Users\\Szymon\\Desktop\\tekturyRAF\\kieliszekprzerobiony.msh","C:\\Users\\Szymon\\Desktop\\tekturyRAF\\butelkaprzerobiona.msh","C:\\Users\\Szymon\\Desktop\\tekturyRAF\\stolprzerobiony.msh","C:\\Users\\Szymon\\Desktop\\tekturyRAF\\szklankaprzerobiona.msh");

    glutCreateWindow("GLUT Shapes");
    glEnable(GL_TEXTURE_2D);
    glGenTextures(LICZBA_OB_TEXTUR, obiektyTextur);
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

    for (int i = 0; i < LICZBA_OB_TEXTUR; i++)
    {
        GLubyte *pBytes;
        GLint iWidth, iHeight, iComponents;
        GLenum eFormat;
        glBindTexture(GL_TEXTURE_2D, obiektyTextur[i]); // dowiazanie obiektow tekstur
        pBytes = glploadtga(plikiTextur[i], &iWidth, &iHeight, &iComponents, &eFormat); // zaladowanie tekstur
        gluBuild2DMipmaps(GL_TEXTURE_2D, iComponents, iWidth, iHeight, eFormat, GL_UNSIGNED_BYTE, pBytes); // utworzenie mipmap
        free(pBytes); // zwolnienie pamieci
    }


    glutReshapeFunc(resize);
    glutDisplayFunc(display);
    glutKeyboardFunc(key);
    glutIdleFunc(idle);

    glClearColor(0.9,0.9,1,1); //kolor tla
  //  glEnable(GL_CULL_FACE);
 //   glCullFace(GL_BACK);

    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);

    glEnable(GL_LIGHT0);
    glEnable(GL_NORMALIZE);
    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_LIGHTING);

    glLightfv(GL_LIGHT0, GL_AMBIENT,  light_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE,  light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);

    glMaterialfv(GL_FRONT, GL_AMBIENT,   mat_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE,   mat_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR,  mat_specular);
    glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    glutMainLoop();
    glDeleteTextures (LICZBA_OB_TEXTUR, obiektyTextur); // usuniecie obiektow tekstur
    return EXIT_SUCCESS;
}