#include "stdafx.h"

#pragma once

#include "targetver.h"
#include <stdio.h>
#include <tchar.h>
#include <math.h>
#include "glaux.h"
#include <stdlib.h>
#include "glut.h"
#include <stdlib.h>
#include <iostream>
#include <fstream>
#include <string>


using namespace std;

 
 
// stała do obsługi menu podręcznego
 
enum
{
        EXIT // wyjście
};
 
GLuint texture[5];

bool LoadModelOBJ(char* filename)
{
    int vert_num=0;
    int triangles=0;

        ifstream myReadFile;
     myReadFile.open(filename);
     string output;
     if (myReadFile.is_open()) {
     while (!myReadFile.eof()) {
        myReadFile >> output;
        if (output=="v") vert_num++;
        if (output=="f") triangles++;
     }
    }

          myReadFile.close();
          myReadFile.open(filename);


     float **vert;
      vert = new float *[vert_num]; //przydzielenie pamięci na w wierszy
 
          for(int i=0;i<vert_num;i++)
            vert[i] = new float[3];


     int **trian;
      trian = new int *[triangles]; //przydzielenie pamięci na w wierszy
 
          for(int i=0;i<triangles;i++)
            trian[i] = new int[3];

         int licz_vert=0;
         int licz_triang=0;

     while (!myReadFile.eof()) {
        myReadFile >> output;
        if (output=="v"){ myReadFile>>vert[licz_vert][0]; myReadFile>>vert[licz_vert][1]; myReadFile>>vert[licz_vert][2]; licz_vert++;}
        if (output=="f"){ myReadFile>>trian[licz_triang][0]; myReadFile>>trian[licz_triang][1]; myReadFile>>trian[licz_triang][2]; licz_triang++;}
     }
    

     glBegin(GL_TRIANGLES);

     for (int i=0;i<triangles;i++)
     {
         glVertex3f(vert[trian[i][0]-1][0],vert[trian[i][0]-1][1],vert[trian[i][0]-1][2]);
         glVertex3f(vert[trian[i][1]-1][0],vert[trian[i][1]-1][1],vert[trian[i][1]-1][2]);
         glVertex3f(vert[trian[i][2]-1][0],vert[trian[i][2]-1][1],vert[trian[i][2]-1][2]);
     }

     glEnd();


      for(int i=0;i<vert_num;i++)
    delete [] vert[i];
  delete [] vert;

   for(int i=0;i<triangles;i++)
    delete [] trian[i];
  delete [] trian;


     return 0;
}

 AUX_RGBImageRec *LoadBMP(char* filename)
{
    FILE* file = NULL;

    if(!filename)
    {
       return NULL;
    }

    file = fopen(filename, "r");

    if(file)
    {
       fclose(file);
       return auxDIBImageLoad(filename);
    }

    return NULL;
}


int LoadGLTextures()
{
    int status = false;

    AUX_RGBImageRec *TextureImage[5];

    memset(TextureImage, 0, sizeof(void *)*1);

    if(TextureImage[0] = LoadBMP("crate.bmp"))
    {
        status = true;

        glGenTextures(1, &texture[0]);

        glBindTexture(GL_TEXTURE_2D, texture[0]);

        gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TextureImage[0]->sizeX, TextureImage[0]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[0]->data);

        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

     }

    if(TextureImage[1] = LoadBMP("metal.bmp"))
    {
        status = true;

        glGenTextures(1, &texture[1]);

        glBindTexture(GL_TEXTURE_2D, texture[1]);

        gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TextureImage[1]->sizeX, TextureImage[1]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[1]->data);

        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

     }

    if(TextureImage[2] = LoadBMP("obraz.bmp"))
    {
        status = true;

        glGenTextures(1, &texture[2]);

        glBindTexture(GL_TEXTURE_2D, texture[2]);

        gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TextureImage[2]->sizeX, TextureImage[2]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[2]->data);

        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

     }

    if(TextureImage[3] = LoadBMP("wall.bmp"))
    {
        status = true;

        glGenTextures(1, &texture[3]);

        glBindTexture(GL_TEXTURE_2D, texture[3]);

        gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TextureImage[3]->sizeX, TextureImage[3]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[3]->data);

        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

     }


    if(TextureImage[4] = LoadBMP("wood.bmp"))
    {
        status = true;

        glGenTextures(1, &texture[4]);

        glBindTexture(GL_TEXTURE_2D, texture[4]);

        gluBuild2DMipmaps(GL_TEXTURE_2D, 3, TextureImage[4]->sizeX, TextureImage[4]->sizeY, GL_RGB, GL_UNSIGNED_BYTE, TextureImage[4]->data);

        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);

        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

     }

        if(TextureImage[0])
        {
            if(TextureImage[0]->data)
            {
               free(TextureImage[0]->data);

            }

            free(TextureImage[0]);
        }

     return status;
}




double PredkoscKamery=0;
 
// pionowy kąt pola widzenia
 
GLdouble fovy = 60;
 
float czajnikrot=0;
 
// wpółrzędne położenia obserwatora
 
GLdouble eyex = 0;
 
GLdouble eyey = 0;
 
GLdouble eyez = 3;
 
GLdouble ObrotX=3.14/2.0;
 
GLdouble ObrotY=0;
 
bool KeyUP=false;
 
bool KeyDOWN=false;
 
bool KeyRIGHT=false;
 
bool KeyLEFT=false;
 
// współrzędne punktu w którego kierunku jest zwrócony obserwator,
 
GLdouble centerx = 0;
 
GLdouble centery = 0;
 
GLdouble centerz = -100;
 
int figure=0;
 
float kat=0;
 
GLuint idlisty;
 
// funkcja generująca scenę 3D
 
void GenerujListyWyswietlania()
 
{
 
        idlisty = glGenLists( 5 );
 
        // utworzenie pierwszej listy
        glNewList( idlisty + 0, GL_COMPILE );
 
        glTranslatef(0,0,10);
 
       glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
glTranslatef(2,0,0);

glDisable(GL_TEXTURE_2D);
          LoadModelOBJ("test4.obj");
 
        glEndList();
 
 
 
        // utworzenie drugiej listy
        glNewList( idlisty + 1, GL_COMPILE );
 
        glTranslatef(0,0,8);
 
        glutSolidTeapot(1);
 
        //glTranslatef(0,0,10);
 
        //glutSolidTeapot(1);
 
        //glTranslatef(0,0,10);
 
        //glutSolidTeapot(1);
 
        glEndList();
 
        // utworzenie trzeciej listy
        glNewList( idlisty + 2, GL_COMPILE );
		
		
  glTranslatef(0,0,10);
		LoadGLTextures();
		glEnable(GL_TEXTURE_2D);
		

		glBindTexture(GL_TEXTURE_2D, texture[0]);
		 glBegin(GL_QUADS);

		
// Front face

glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);

glTexCoord2f(3.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);

glTexCoord2f(3.0f, 3.0f); glVertex3f( 1.0f, 1.0f, 1.0f);

glTexCoord2f(0.0f, 3.0f); glVertex3f(-1.0f, 1.0f, 1.0f);

// Back face

glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);

glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);

glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);

glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);

// Top face

glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);

glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 1.0f);

glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, 1.0f, 1.0f);

glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);

// Bottom face

glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, -1.0f, -1.0f);

glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, -1.0f, -1.0f);

glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);

glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);

// Right face

glTexCoord2f(1.0f, 0.0f); glVertex3f( 1.0f, -1.0f, -1.0f);

glTexCoord2f(1.0f, 1.0f); glVertex3f( 1.0f, 1.0f, -1.0f);

glTexCoord2f(0.0f, 1.0f); glVertex3f( 1.0f, 1.0f, 1.0f);

glTexCoord2f(0.0f, 0.0f); glVertex3f( 1.0f, -1.0f, 1.0f);

// Left face

glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, -1.0f, -1.0f);

glTexCoord2f(1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 1.0f);

glTexCoord2f(1.0f, 1.0f); glVertex3f(-1.0f, 1.0f, 1.0f);

glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, 1.0f, -1.0f);

glEnd();
        glEndList();


// utworzenie czwratej listy
        glNewList( idlisty + 3, GL_COMPILE );

glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

int vert_num=8;
int face_num=12;

//tablice statyczne
// float vert[8][3];
// int face[12][3];

//tablice dynamiczne

float **vert;
vert = new float *[vert_num];

for (int i=0; i<vert_num; i++)
	vert[i] = new float[3];


int **face;
face = new int *[face_num];

for (int i=0; i<face_num; i++)
	face[i] = new int[3];

vert[0][0]= 1.000000;
vert[0][1]=-1.000000;
vert[0][2]= -1.000000;
vert[1][0]= 1.000000;
vert[1][1]= -1.000000;
vert[1][2]= 1.000000;
vert[2][0]= -1.000000;
vert[2][1]= -1.000000;
vert[2][2]= 1.000000;
vert[3][0]= -1.000000;
vert[3][1]= -1.000000;
vert[3][2]= -1.000000;
vert[4][0]= 1.000000;
vert[4][1]= 1.000000;
vert[4][2]= -0.999999;
vert[5][0]= 0.999999;
vert[5][1]= 1.000000;
vert[5][2]= 1.000001;
vert[6][0]= -1.000000;
vert[6][1]= 1.000000;
vert[6][2]= 1.000000;
vert[7][0]= -1.000000;
vert[7][1]= 1.000000;
vert[7][2]= -1.000000;

face[0][0]=1; face[0][1]=2; face[0][2]=3;

face[1][0]=5; face[1][1]=8; face[1][2]=7;

face[2][0]=1; face[2][1]=5; face[2][2]=6;

face[3][0]=2; face[3][1]=6; face[3][2]=3;

face[4][0]=3; face[4][1]=7; face[4][2]=4;

face[5][0]=5; face[5][1]=1; face[5][2]=4;

face[6][0]=4; face[6][1]=1; face[6][2]=3;

face[7][0]=6; face[7][1]=5; face[7][2]=7;

face[8][0]=2; face[8][1]=1; face[8][2]=6;

face[9][0]=6; face[9][1]=7; face[9][2]=3;

face[10][0]=7; face[10][1]=8; face[10][2]=4;

face[11][0]=8; face[11][1]=5; face[11][2]=4;

int i=0;

glBegin(GL_TRIANGLES);
for(int i=0;i<12;i++)
	{
		glVertex3f(vert[face[i][0]-1][0],vert[face[i][0]-1][1],vert[face[i][0]-1][2]);
		glVertex3f(vert[face[i][1]-1][0],vert[face[i][1]-1][1],vert[face[i][1]-1][2]);
		glVertex3f(vert[face[i][2]-1][0],vert[face[i][2]-1][1],vert[face[i][2]-1][2]);
	}

for (int i=0; i<8; i++)
	delete [] vert[i];
	delete [] vert;

for (int i=0; i<12; i++)
	delete [] face[i];
	delete [] face;



glEnd();
glEndList();



}
 
void UstawKamere()
{
        double cosx, siny, sinx;
 
        double CelX, CelY, CelZ;
 
        // wartości funkcji trygonometrycznych
 
        // obliczamy tylko raz dla oszczędności
 
        if (KeyDOWN) PredkoscKamery=-0.05;
 
        if (KeyUP) PredkoscKamery=0.05;
 
        if (KeyLEFT) ObrotX-=0.07;
 
        if (KeyRIGHT) ObrotX+=0.07;
 
        siny = sin(ObrotY);
 
        cosx = cos(ObrotX);
 
        sinx = sin(ObrotX);
 
        // nowa pozycja kamery
 
        eyex += cosx*PredkoscKamery;
 
        eyey += siny*PredkoscKamery;
 
        eyez += sinx*PredkoscKamery;
 
        // punkt wycelowania kamery powinien
 
        // znajdować się gdzieś "przed jej nosem"
 
        CelX = eyex+cosx;
 
        CelY = eyey+siny;
 
        CelZ = eyez+sinx;
 
        gluLookAt(eyex, eyey, eyez,CelX, CelY, CelZ, 0, 1, 0);
 
        //gluLookAt( eyex, eyey, eyez, centerx, centery, centerz, 0, 1, 0 );
 
        PredkoscKamery=0;
}
 
void Display()
{
        // kolor tła - zawartość bufora koloru
        glClearColor( 1.0, 0.0, 1.0, 1.0 );
 
        glEnable(GL_DEPTH_TEST);
 
        // czyszczenie bufora koloru
        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 
        // wybór macierzy modelowania
        glMatrixMode( GL_MODELVIEW );
 
        // macierz modelowania = macierz jednostkowa
        glLoadIdentity();
 
        UstawKamere();
 
        // ustawienie obserwatora
 
        //glRotatef(kat,1,0,0);
 
        // przesunięcie obiektu o wektor [0,0,-3]
 
        //glTranslatef( 0, 0, 2.0 );
 
        // kolor krawędzi sześcianu
        glColor3f( 0.5, 1.0, 0.5 );
 
        /*glEnable(GL_LIGHTING);
        GLfloat ambientlight[]={1.0, 1.0, 1.0, 1.0};
        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientlight);
        GLfloat gray[] = {0.75, 0.75, 0.75, 1.0};
        glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gray);*/
 
        glEnable(GL_COLOR_MATERIAL);
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
       
        glNormal3f(0.0, -1.0, 0.0);
         
        glEnable(GL_NORMALIZE);
         
        GLfloat DiffuseLight1[]={1.0,1.0,1.0,1.0};
        GLfloat LightPosition1[]={0.0, 100.0, -100.0, 1.0};
        GLfloat AmbientLight[]={0.1, 0.1, 0.1, 1.0};
         
        glLightfv( GL_LIGHT0, GL_DIFFUSE, DiffuseLight1 );
        glLightfv( GL_LIGHT0, GL_POSITION, LightPosition1 );
        glLightfv( GL_LIGHT0, GL_AMBIENT, AmbientLight );
 
        GLfloat specular[]={1.0,1.0,1.0,1.0};
 
        glLightfv( GL_LIGHT0, GL_SPECULAR, specular );
       
        GLfloat specref[]={1.0,1.0,1.0,1.0};
        glMaterialfv(GL_FRONT, GL_SPECULAR, specref);
        glMateriali(GL_FRONT, GL_SHININESS, 128);
         
       
 
        // glutWireCube(1);
        switch (figure)
        {
                case 1:
                        glCallList(idlisty+0);
                        break;
 
                case 2:
                        glCallList(idlisty+1);
                        break;
 
                case 3:
                        glCallList(idlisty+2);
                        break;

				case 4:
                        glCallList(idlisty+3);
                        break;
        }
 
        // skierowanie poleceń do wykonania
        glFlush();
 
        // zamiana buforów koloru
        glutSwapBuffers();
 
}
 
// zmiana wielkości okna
 
void Reshape( int width, int height )
{
        // obszar renderingu - całe okno
        glViewport( 0, 0, width, height );
 
        // wybór macierzy rzutowania
        glMatrixMode( GL_PROJECTION );
 
        // macierz rzutowania = macierz jednostkowa
        glLoadIdentity();
 
        // obliczenie aspektu obrazu z uwzględnieniem
        // przypadku, gdy wysokość obrazu wynosi 0
        GLdouble aspect = 1;
 
        if( height > 0 )
 
                aspect = width /( GLdouble ) height;
 
        // rzutowanie perspektywiczne
        gluPerspective( fovy, aspect, 0.01, 100.0 );
 
        // generowanie sceny 3D
        Display();
}
 
// obsługa klawiatury
 
void Klawisze( unsigned char key, int x, int y )
 
{
        // klawisz +
        if( key == '+' && fovy < 180 )
                fovy++;
 
        // klawisz -
        if( key == '-' && fovy > 0 )
                fovy--;
 
        if( key == 'a' && fovy > 0 )
                kat++;
 
        if( key == 'w' )
                PredkoscKamery=0.02;
 
        if( key == 's' )
                PredkoscKamery=-0.02;
 
        if( key == 'e' )
                ObrotX+=0.02;
 
        if( key == 'q' )
                ObrotX-=0.02;
 
        if( key == 'r' )
                ObrotY+=0.02;
 
        if( key == 'f' )
                ObrotY-=0.02;
 
        // odrysowanie okna
        Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
}
 
void KlawiszeSpecjalne( int key, int x, int y )
{
        switch( key )
        {
                // kursor w lewo
        case GLUT_KEY_LEFT:
                eyex += 0.1;
                break;
 
                // kursor w górę
        case GLUT_KEY_UP:
                eyey -= 0.1;
                break;
 
                // kursor w prawo
        case GLUT_KEY_RIGHT:
                eyex -= 0.1;
                break;
 
                // kursor w dół
        case GLUT_KEY_DOWN:
                eyey += 0.1;
                break;
        }
        // odrysowanie okna
        Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
}
 
// obsługa menu podręcznego
 
void Menu( int value )
{
 
        switch( value )
        {
                // wyjście
        case EXIT:
 
                exit( 0 );
 
                // wyjście
        case 1:
 
                figure=1;
 
                break;
 
        case 2:
 
                figure=2;
 
                break;
 
        case 3:
 
                figure=3;
 
                break;

		case 4:

				figure=4;

				break;
 
        }
 
        Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
}
 
void KeyDown(int key,int x,int y)
{
 
        switch(key){
 
        case GLUT_KEY_UP:
 
                KeyUP=true;
 
                break;
 
        case GLUT_KEY_DOWN:
 
                KeyDOWN=true;
 
                break;
 
        case GLUT_KEY_LEFT:
 
                KeyLEFT=true;
 
 
                break;
 
        case GLUT_KEY_RIGHT:
 
                KeyRIGHT=true;
 
                break;
        }
}
 
void KeyUp(int key,int x,int y)
{
 
        switch(key)
        {
                case GLUT_KEY_UP:
                        KeyUP=false;
                        break;
 
                case GLUT_KEY_DOWN:
                        KeyDOWN=false;
                        break;
 
                case GLUT_KEY_LEFT:
                        KeyLEFT=false;
                        break;
 
                case GLUT_KEY_RIGHT:
                        KeyRIGHT=false;
                        break;
        }
}
 
int main( int argc, char * argv[] )
{
        // inicjalizacja biblioteki GLUT
        glutInit( & argc, argv );
 
        // inicjalizacja bufora ramki
        glutInitDisplayMode( GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH );
 
        // rozmiary głównego okna programu
        glutInitWindowSize( 400, 400 );
 
        // utworzenie głównego okna programu
#ifdef WIN32
        glutCreateWindow( "Sześcian 3" );
#else
        glutCreateWindow( "Szescian 3" );
#endif
 
        // dołączenie funkcji generującej scenę 3D
        glutDisplayFunc( Display );
 
        // dołączenie funkcji wywoływanej przy zmianie rozmiaru okna
        glutReshapeFunc( Reshape );
 
        // dołączenie funkcji obsługi klawiatury
        glutKeyboardFunc( Klawisze );
 
        // dołączenie funkcji obsługi klawiszy funkcyjnych i klawiszy kursora
        // glutSpecialFunc( KlawiszeSpecjalne );
 
        glutSpecialFunc(KeyDown);
 
        glutSpecialUpFunc(KeyUp);
 
        // utworzenie menu podręcznego
        glutCreateMenu( Menu );
 
        // dodanie pozycji do menu podręcznego
        glutAddMenuEntry( "Wyjście", EXIT );
        glutAddMenuEntry( "Rys1", 1 );
        glutAddMenuEntry( "Rys2", 2 );
        glutAddMenuEntry( "Rys3", 3 );
        glutAddMenuEntry( "Rys4", 4 );
 
        // określenie przycisku myszki obsługującej menu podręczne
        glutAttachMenu( GLUT_RIGHT_BUTTON );
 
        GenerujListyWyswietlania();
 
        glutIdleFunc(Display);
        // wprowadzenie programu do obsługi pętli komunikatów
        glutMainLoop();
        return 0;
}