zadanie4

#include <windows.h>
#include <iostream>
#include <GL/glut.h>
#include <stdlib.h>
#include <math.h>
#define GL_PI 3.1415f
#include <GL/glut.h>
#include <stdlib.h>

using namespace std;



// sta³a do obs³ugi menu podrêcznego

enum
{
    FULL_WINDOW,
    ASPECT_1_1,
    ORTO,
    FRUST,
    PERSP,
    POWIERZCHNIA,
    GLEBIA,
    SZKIELET,
    WYPELNIENIE,
    EXIT // wyjœcie
};



GLfloat x,y,angle; // Przechowują wartości współrzędnych i kąta
int iPivot = 1;
int rzut,skala,wybierz;
bool iCull=false,iDepth=false,iOutline=false,iFill=false,iClock=false;
double xx,xy,zx,yx,obrot_x=0.0,obrot_y=0.0,yy,zy;
double dx=0.0,dy=0.0,dz=0.0;
GLdouble fovy =90,eyex=1.0,eyey=1.0,eyez=1.0;




// funkcja generuj¹ca scenê 3D


void Display()

{
    glClear(GL_COLOR_BUFFER_BIT);
    glClearColor(0.0,0.0,0.0,0.0);
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    //gluLookAt(dx, dy, dz, eyex, eyey, eyez, 0.0, 1.0, 0.0);
    gluLookAt(eyex, eyey, eyez, 0, 0, 0, 0.0, 1.0, 0.0);
    glRotatef(obrot_x,xx,xy,zx);
    glRotatef(obrot_y,xy,yy,zy);
    glTranslatef (0.0f,0.0f,dx);
    glColor3f(1.0,0.0,0.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);



    // pocz¹tek definicji krawêdzi szeœcianu
    glBegin(GL_TRIANGLE_FAN); // Rysowanie ściany bocznej stożka
    glVertex3f(0.0f, 0.0f, 0.75f); // Czubek stożka jest wspólnym wierzchołkiem wszystkich trójkątów z wachlarza.
    for(angle = 0.0f; angle < (2.0f*M_PI); angle += (M_PI/8.0f))
        {
            x = 0.5f*sin(angle); // Wyliczenie współrzędnych x i y kolejnego wierzchołka
            y = 0.5f*cos(angle);
            if((iPivot %2) == 0) // Wybieranie koloru - zielony lub czerwony
                glColor3f(0.0f, 1.0f, 0.0f);
            else
                glColor3f(1.0f, 0.0f, 0.0f);
            iPivot++; // Inkrementacja zmiennej określającej rodzaj koloru
            // Definiowanie kolejnego wierzchołka w wachlarzu trójkątów
            glVertex2f(x, y);
        }
    glEnd();

    glBegin(GL_TRIANGLE_FAN); // Rozpoczęcie rysowania kolejnego wachlarza trójkątów zakrywającego podstawę stożka
    glVertex2f(0.0f, 0.0f); // Środek wachlarza znajduje się na początku układu współrzędnych
    for(angle = 0.0f; angle < (2.0f*GL_PI); angle += (GL_PI/8.0f))
        {
            x = 0.50f*sin(angle); // Wyliczenie współrzędnych x i y kolejnego wierzchołka
            y = 0.50f*cos(angle);
            if((iPivot %2) == 0) // Wybieranie koloru - zielony lub czerwony
                glColor3f(0.1f, 0.1f, 0.1f);
            else
                glColor4f(1.0f, 1.0f, 0.0f, 0.0f);
            iPivot++; // Inkrementacja zmiennej określającej rodzaj koloru
            glVertex2f(x, y); // Definiowanie kolejnego wierzchołka w wachlarzu trójkątów
        }
    glEnd(); // Zakończenie rysowania trójkątów podstawy stożka

    glBegin(GL_TRIANGLE_STRIP);
        for(angle = 0.0f; angle < (2.0f*GL_PI); angle += (GL_PI/8.0f))
        {
            x = 0.10f*sin(angle); // Wyliczenie współrzędnych x i y kolejnego wierzchołka
            y = 0.10f*cos(angle);
            if((iPivot %2) == 0) // Wybieranie koloru - zielony lub czerwony
                glColor3f(0.1f, 0.1f, 0.1f);
            else
                glColor4f(1.0f, 1.0f, 0.0f, 0.0f);
            iPivot++; // Inkrementacja zmiennej określającej rodzaj koloru
            glVertex3f(x, y,-0.5); // Definiowanie kolejnego wierzchołka w wachlarzu trójkątów
            glVertex3f(x, y,0.2);
        }
    glEnd();
    glBegin(GL_TRIANGLE_FAN); // Rozpoczęcie rysowania kolejnego wachlarza trójkątów zakrywającego podstawę stożka
    glVertex3f(0.0f, 0.0f,0.2); // Środek wachlarza znajduje się na początku układu współrzędnych
    for(angle = 0.0f; angle < (2.0f*GL_PI); angle += (GL_PI/8.0f))
        {
            x = 0.10f*sin(angle); // Wyliczenie współrzędnych x i y kolejnego wierzchołka
            y = 0.10f*cos(angle);
            if((iPivot %2) == 0) // Wybieranie koloru - zielony lub czerwony
                glColor3f(0.1f, 0.1f, 0.1f);
            else
                glColor4f(1.0f, 1.0f, 0.0f, 0.0f);
            iPivot++; // Inkrementacja zmiennej określającej rodzaj koloru
            glVertex3f(x, y,0.2); // Definiowanie kolejnego wierzchołka w wachlarzu trójkątów
        }
    glEnd();
     glBegin(GL_TRIANGLE_FAN); // Rozpoczęcie rysowania kolejnego wachlarza trójkątów zakrywającego podstawę stożka
    glVertex3f(0.0f, 0.0f,-0.5); // Środek wachlarza znajduje się na początku układu współrzędnych
    for(angle = 0.0f; angle < (2.0f*GL_PI); angle += (GL_PI/8.0f))
        {
            x = 0.10f*sin(angle); // Wyliczenie współrzędnych x i y kolejnego wierzchołka
            y = 0.10f*cos(angle);
            if((iPivot %2) == 0) // Wybieranie koloru - zielony lub czerwony
                glColor3f(0.1f, 0.1f, 0.1f);
            else
                glColor4f(1.0f, 1.0f, 0.0f, 0.0f);
            iPivot++; // Inkrementacja zmiennej określającej rodzaj koloru
            glVertex3f(x, y,-0.5); // Definiowanie kolejnego wierzchołka w wachlarzu trójkątów
        }
    glEnd();
    // 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 ();
    // ustawienie parametrów zakresu rzutni
    GLdouble aspect = 1;
    GLfloat zakres = 3.0f;
    GLfloat blisko = 1.0f;
    GLfloat daleko = 5.0;

    if (rzut==ORTO)
    {
        if (skala==ASPECT_1_1)
        {
            if (width < height && width > 0)
                glOrtho (-zakres,zakres,-zakres*height/width,zakres*height/width,-zakres,zakres);
            else if (width >= height && height > 0)
                glOrtho (-zakres*width/height,zakres*width/height,-zakres,zakres,-zakres,zakres);
        }
        else
            glOrtho (-zakres,zakres,-zakres,zakres,-zakres,zakres);
    }

    if (rzut==FRUST)
    {
        if (skala==ASPECT_1_1)
        {
            if (width < height && width > 0)
                glFrustum (-zakres,zakres,-zakres*height/width,zakres*height/width,blisko,daleko);
            else if (width >= height && height > 0)
                glFrustum (-zakres*width/height,zakres*width/height,-zakres,zakres,blisko,daleko);
        }
        else
            glFrustum (-zakres,zakres,-zakres,zakres,blisko,daleko);
    }
    if (rzut==PERSP)
    {
        if (height > 0)
            aspect = width/(GLdouble)height;
        gluPerspective (45,aspect,blisko,daleko);
    }
    if (wybierz==POWIERZCHNIA)
    {
        if(iCull==true)
        glEnable(GL_CULL_FACE);
        else
        glDisable(GL_CULL_FACE);
    }

    if (wybierz==GLEBIA)
    {
        if(iDepth==true)
        glEnable(GL_DEPTH_TEST);
        else
        glDisable(GL_DEPTH_TEST);
    }
    if (wybierz==SZKIELET)
    {
        if(iOutline==true)
        glPolygonMode(GL_BACK,GL_LINE);
        else
        glPolygonMode(GL_BACK,GL_FILL);
    }
     if (wybierz==WYPELNIENIE)
    {
        if(iClock==true)
        glShadeModel(GL_FLAT);
        else
        glShadeModel(GL_SMOOTH);
    }



    Display ();
}



// obs³uga menu podrêcznego

void Menu (int value)
{
    switch (value)
    {
// wyjœcie
    case EXIT:
        exit (0);
    case POWIERZCHNIA:
        wybierz=POWIERZCHNIA;
        if(iCull==false)
        {
            iCull=true;
            cout<<"iCull = TRUE"<<endl;
        }
        else
        {
          iCull=false;
            cout<<"iCull = False"<<endl;
        }

    break;
    case GLEBIA:
        wybierz=GLEBIA;
        if(iDepth==false)
        {
            iDepth=true;
            cout<<"iDepth = TRUE"<<endl;
        }
        else
        {
          iDepth=false;
            cout<<"iDepth = False"<<endl;
        }
        break;
    case SZKIELET:
        wybierz=SZKIELET;
        if(iOutline==false)
        {
            iOutline=true;
            cout<<"iOutline = TRUE"<<endl;
        }
        else
        {
          iOutline=false;
            cout<<"iOutline = False"<<endl;
        }
        break;
    case WYPELNIENIE:
        wybierz=WYPELNIENIE;
        if(iClock==false)
        {
            iClock=true;
            cout<<"iClock = TRUE"<<endl;
        }
        else
        {
          iClock=false;
            cout<<"iClock = False"<<endl;
        }
    break;
    }
}
void skal(int value)
{
    switch (value)
    {
        case FULL_WINDOW:
        skala=FULL_WINDOW;
        Reshape (glutGet (GLUT_WINDOW_WIDTH),glutGet (GLUT_WINDOW_HEIGHT));
        break;
        case ASPECT_1_1:
        skala=ASPECT_1_1;
        Reshape (glutGet (GLUT_WINDOW_WIDTH),glutGet (GLUT_WINDOW_HEIGHT));
        break;
    }
}

void resh(int value)
{
    switch (value)
    {
    case ORTO:
        rzut=ORTO;
        Reshape (glutGet (GLUT_WINDOW_WIDTH),glutGet (GLUT_WINDOW_HEIGHT));
        break;
    case FRUST:
        rzut=FRUST;
        Reshape (glutGet (GLUT_WINDOW_WIDTH),glutGet (GLUT_WINDOW_HEIGHT));
        break;
    case PERSP:
        rzut=PERSP;
        Reshape (glutGet (GLUT_WINDOW_WIDTH),glutGet (GLUT_WINDOW_HEIGHT));
        break;
    }
}
void Funkcja_klawiatury (unsigned char key, int x, int y)
{
    if (key == 'a')
    {
        xx=0;
        yx=1;
        zx=0;
        obrot_x=obrot_x+5;
        cout<<"obrot_x= "<<obrot_x<<endl;
    }
    if (key == 'd')
    {
        xx=0;
        yx=1;
        zx=0;
        obrot_x=obrot_x-5;
        cout<<"obrot_x= "<<obrot_x<<endl;
    }
    if (key == 'w')
    {
        xy=1;
        yy=0;
        zy=0;
        obrot_y=obrot_y+5;
        cout<<"obrot_y= "<<obrot_y<<endl;
    }
    if (key == 's')
    {
        xy=1;
        yy=0;
        zy=0;
        obrot_y=obrot_y-5;
        cout<<"obrot_y= "<<obrot_y<<endl;
    }

    Reshape (glutGet (GLUT_WINDOW_WIDTH),glutGet (GLUT_WINDOW_HEIGHT));
}
void specialKey(int klawisz, int x, int y)
{
cout << " klawisz" << klawisz << endl;
if(klawisz == 101)
{
//dx+=0.1;
eyey-=0.1;
cout<<"dx="<<eyex<<endl;
}
if(klawisz == 103)
{
//dx-=0.1;
eyey+=0.1;
cout<<"dx="<<eyex<<endl;
}
if(klawisz == 100)
{
//dx+=0.1;
eyex-=0.1;
cout<<"dx="<<eyex<<endl;
}
if(klawisz == 102)
{
//dx-=0.1;
eyex+=0.1;
cout<<"dx="<<eyex<<endl;
}

Reshape (glutGet (GLUT_WINDOW_WIDTH),glutGet (GLUT_WINDOW_HEIGHT));
}


    int main(int argc, char *argv[])
{
    rzut=ORTO;
    cout<<"STROWANIE"<<endl;
    cout<<"********************************************************"<<endl;
    cout<<"ZMIANA POLOZENIA X - strzałka w lewo lub w prawo"<<endl;
    cout<<"ZMIANA POLOZENIA Y - strzałka w dół lub gore"<<endl;
    cout<<"********************************************************"<<endl;
    cout<<"OBROT W OSI X - przyciski a i d"<<endl;
    cout<<"OBROT W OSI Y - przyciski w i s"<<endl;
    cout<<"********************************************************"<<endl;
    cout<<"Po wybraniu opcji z menu wcisnij klawisz"<<endl;
    cout<<"Klawisz 'D' jest zbugowany, przed jego wcisnieciem nalezy wcisnac klawisz 'W','S' lub 'A' "<<endl;




    glutInit(&argc, argv);
    glutInitWindowSize(640,480);
    glutInitWindowPosition(10,10);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

    glutCreateWindow("Zadanie 4");

    glutReshapeFunc(Reshape);
    glutDisplayFunc(Display);

    int sub1=glutCreateMenu(skal);
        glutAddMenuEntry ("Rodzaj skalowania - cale okno",FULL_WINDOW);
        glutAddMenuEntry ("Rodzaj skalowania - skala 1:1",ASPECT_1_1);
    int sub2=glutCreateMenu(resh);
    glutAddMenuEntry ("Rzutowanie ortogonalne", ORTO);
    glutAddMenuEntry ("Rzutowanie frustum", FRUST);
    glutAddMenuEntry ("Rzutowanie perspective", PERSP);
    int mainmenu =glutCreateMenu(Menu);
    glutAddSubMenu("Skalowanie",sub1);
    glutAddSubMenu("Rzutowanie", sub2);
    glutAddMenuEntry ("Ukrywanie powierzchni niewidocznych", POWIERZCHNIA);
    glutAddMenuEntry ("Testowanie glebi", GLEBIA);
    glutAddMenuEntry ("Rysowanie szkieletu", SZKIELET);
    glutAddMenuEntry ("Wypelnienie obiektow", WYPELNIENIE);
    glutAddMenuEntry ("Wyjscie",EXIT);
    glutAttachMenu (GLUT_RIGHT_BUTTON);

    glutKeyboardFunc(Funkcja_klawiatury);
    glutSpecialFunc(specialKey);
    glutMainLoop();

    return EXIT_SUCCESS;
}