zadanie_oswietlenie

#include <windows.h>
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
#include <math.h>
#include <stdlib.h>
#include <iostream>
#include <time.h>

using namespace std;

enum
{
    ORTO,
    ASPECT_1_1,
    FRUST,
    PERSP,
    EXIT,
    FULL_WINDOW,
    SWIATLO_OGOLNE,
    REFLEKTOR,
};

int rzut,skala;

int edytuj = 1;

GLdouble positionX =0.0;
GLdouble positionY =0.0;
GLdouble positionZ =-38.0;
GLdouble angleA=0.0;

GLdouble PI = 3.14;
GLdouble alfa = -PI / 2;
GLdouble skok_point = 10.0;
GLdouble skok_eye = 1.0;

GLfloat eyex=0.0;
GLfloat eyey=0.0;
GLfloat eyez=1.0;

GLfloat fskupienie =6.0f;
GLfloat frozwarcie =60.0f;

GLfloat pointx = skok_point * cos (alfa);
GLfloat pointy = 0.0;
GLfloat pointz = skok_point * sin (alfa);

GLdouble fovy =45;

GLfloat fPozycja_swiatla[] = {100.0f, 100.0f, 50.0f, 1.0f};
GLfloat fSlabe_swiatlo[] = {0.25f, 0.25f, 0.25f, 1.0f};
GLfloat fMocne_swiatlo[] = {1.0f, 1.0f, 1.0f, 1.0f};

GLfloat fPozycja_reflektora[4] = {eyex, eyey, eyez, 10.0f};
GLfloat fKierunek_reflektora[4] = {pointx, pointy, pointz, 1.0f}; // kierunek w którym ma œwieciæ reflektor

GLfloat ambient_materials[] = {0.329412, 0.223529, 0.027451, 1.0};
GLfloat diffuse_materials[] = {0.780392, 0.568627, 0.113725, 1.0};
GLfloat specular_materials[] = {0.992157, 0.941176, 0.807843, 1.0};
GLfloat shininess_materials = 27.8974;

int width = 640;
int height = 480;

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

    GLdouble aspect = -1.0;
    GLdouble zakres = 1.0;
    GLdouble blisko = 2.0;
    GLdouble daleko = 100.0;

    GLdouble zakresORTO = 15.0;

    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    //glFrustum(-ar, ar, -1.0, 1.0, 2.0, 100.0);
    //glOrtho(-ar, ar, -1.0, 1.0, 2.0, 100.0);
    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==ORTO)
    {
        if (skala==ASPECT_1_1)
        {
            if (width < height && width > 0)
                glOrtho (-zakresORTO,zakresORTO,-zakresORTO*height/width,zakresORTO*height/width,-blisko,daleko);
            else if (width >= height && height > 0)
                glOrtho (-zakresORTO*width/height,zakresORTO*width/height,-zakresORTO,zakresORTO,-blisko,daleko);
        }
        else
            glOrtho (-zakresORTO,zakresORTO,-zakresORTO,zakresORTO,-blisko,daleko);
    }
    if (rzut==PERSP)
    {
        if (height > 0)
            aspect = width/(GLdouble)height;
        gluPerspective (90,aspect,blisko,daleko);
    }

    gluLookAt(eyex,eyey,eyez,pointx,pointy,pointz,0,1,0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity() ;
}
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);

    glPushMatrix();
        glTranslated(positionX,positionY,positionZ);
        //glRotated(45,0.5,0.5,0.5);
        glColor3d(1,0,0);
        //glScaled(5,5.5,2.0);
        glScaled(1,1.0,1.0);
        glutSolidCube(25);
    glPopMatrix();
    glPushMatrix();
        glColor3d(0,1,0);
        glRotated(a,0,1,0);
        glTranslated(positionX +30,positionY,positionZ +10);
        glutSolidTeapot(15);
    glPopMatrix();
        glFlush();
        glutSwapBuffers();
}

void xyzoka()
{
    cout<<"OKO -X : "<<eyex<<"OKO -Y : "<<eyey<<"OKO -Z : "<<eyez<<endl;
}
void xyzcentrum()
{
    cout<<"centrum -X : "<<pointx<<"centrum -Y : "<<pointy<<"centrum -Z : "<<pointz<<endl;
}

static void key(unsigned char key, int x, int y)
{
    switch (key)
    {
        case '1':
            edytuj = 1;
            cout<<"teraz edytujesz kat rozwarcia reflektora za pomoca klawiszy [+/-]"<<endl;
        break;
        case '2':
            edytuj = 2;
            cout<<"teraz edytujesz skupienie reflektora za pomoca klawiszy [+/-]"<<endl;
        break;
        case '3':
            edytuj = 3;
            cout<<"teraz edytujesz kierunek reflektora za pomoca klawiszy [+/-]"<<endl;
        break;
        case '-' :
            if(edytuj == 1)
            {
                frozwarcie-=0.1f;
                glLightf (GL_LIGHT1, GL_SPOT_CUTOFF, frozwarcie);
                cout<<"rozwarcie kata : "<<frozwarcie<<endl;
            }
            if(edytuj == 2)
            {
                fskupienie-=0.1f;
                glLightf(GL_LIGHT1,GL_SPOT_EXPONENT,fskupienie);
                cout<<"skupienie reflektora : "<<fskupienie<<endl;
            }
        break;
        case '+' :
            if(edytuj == 1)
            {
                frozwarcie+=0.1f;
                glLightf (GL_LIGHT1, GL_SPOT_CUTOFF, frozwarcie);
                cout<<"rozwarcie kata : "<<frozwarcie<<endl;
            }
            if(edytuj == 2)
            {
                fskupienie+=0.1f;
                glLightf(GL_LIGHT1,GL_SPOT_EXPONENT,fskupienie);
                cout<<"skupienie reflektora : "<<fskupienie<<endl;
            }
        break;
        case 'w':
        skok_eye += 1.0f;
        eyex = skok_eye * cos (alfa) + eyex;
        eyez = skok_eye * sin (alfa) + eyez;
        pointx = skok_point * cos (alfa) + eyex;
        pointz = skok_point * sin (alfa) + eyez;
        glLightfv (GL_LIGHT1, GL_POSITION, fPozycja_reflektora);

        skok_eye = 1.0f;
        break;
        case 's':
        skok_eye -= 1.0f;
        eyex = skok_eye * cos (alfa) + eyex;
        eyez = skok_eye * sin (alfa) + eyez;
        pointx = skok_point * cos (alfa) + eyex;
        pointz = skok_point * sin (alfa) + eyez;
        glLightfv (GL_LIGHT1, GL_POSITION, fPozycja_reflektora);
        break;
    }
    Reshape( glutGet( GLUT_WINDOW_WIDTH ), glutGet( GLUT_WINDOW_HEIGHT ) );
}

void SpecialKeys( int key, int x, int y )
{
    switch( key )
    {
    case GLUT_KEY_LEFT:
        if(edytuj == 3)
        {
            fKierunek_reflektora[0] -= 1.0f;
            glLightfv (GL_LIGHT1, GL_SPOT_DIRECTION, fKierunek_reflektora);
            cout<<"kierunek X reflektora : "<< fKierunek_reflektora[0]<<endl;
        }
        else
        {
        alfa -= PI / 32;
        pointx = skok_point * cos (alfa) + eyex;
        pointz = skok_point * sin (alfa) + eyez;
                fKierunek_reflektora[0] = pointx;
                fKierunek_reflektora[2] = pointz;
        glLightfv (GL_LIGHT1, GL_SPOT_DIRECTION, fKierunek_reflektora);
        cout<<"kierunek X reflektora : "<< fKierunek_reflektora[0]<<endl;

        }
        break;
    case GLUT_KEY_RIGHT:
        if(edytuj == 3)
        {
            fKierunek_reflektora[0] += 1.0f;
            glLightfv (GL_LIGHT1, GL_SPOT_DIRECTION, fKierunek_reflektora);
            cout<<"kierunek X reflektora : "<< fKierunek_reflektora[0]<<endl;
        }
        else
        {
        alfa += PI / 32;
        pointx = skok_point * cos (alfa) + eyex;
        pointz = skok_point * sin (alfa) + eyez;
                fKierunek_reflektora[0] = pointx;
                fKierunek_reflektora[2] = pointz;
        glLightfv (GL_LIGHT1, GL_SPOT_DIRECTION, fKierunek_reflektora);
        cout<<"kierunek X reflektora : "<< fKierunek_reflektora[0]<<endl;
        }
        break;
    case GLUT_KEY_UP:
        if(edytuj == 3)
        {
            fKierunek_reflektora[1] += 1.0f;
            glLightfv (GL_LIGHT1, GL_SPOT_DIRECTION, fKierunek_reflektora);
        }
        else
        {
        alfa -= PI / 32;
        pointz = skok_point * cos (alfa) + eyez;
        pointy = skok_point * sin (alfa) + eyey;
                     fKierunek_reflektora[1] = pointy;
                     fKierunek_reflektora[2] = pointz;
            glLightfv (GL_LIGHT1, GL_SPOT_DIRECTION, fKierunek_reflektora);
            cout<<"kierunek Y reflektora : "<< fKierunek_reflektora[1]<<endl;
        }
        break;
    case GLUT_KEY_DOWN:
        if(edytuj == 3)
        {
            fKierunek_reflektora[1] -= 1.0f;
            glLightfv (GL_LIGHT1, GL_SPOT_DIRECTION, fKierunek_reflektora);
            cout<<"kierunek Y reflektora : "<< fKierunek_reflektora[1]<<endl;
        }
        else
        {
        alfa += PI / 32;
        pointz = skok_point * cos (alfa) + eyez;
        pointy = skok_point * sin (alfa) + eyey;
                    fKierunek_reflektora[1] = pointy;
                    fKierunek_reflektora[2] = pointz;
            glLightfv (GL_LIGHT1, GL_SPOT_DIRECTION, fKierunek_reflektora);
            cout<<"kierunek Y reflektora : "<< fKierunek_reflektora[1]<<endl;
        }
        break;
    }

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

void TimerFunction (int value)
{
    glutPostRedisplay ();
    glutTimerFunc(3, TimerFunction, 1);
    angleA+=1.0;

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

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 };
const GLfloat light_position[] = { 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 };

void Menu (int value)
{
    switch (value)
    {
    case EXIT:
        exit (0);
        case REFLEKTOR:
        glDisable(GL_LIGHT0);
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT1);
        break;
        case SWIATLO_OGOLNE:
        glDisable(GL_LIGHT1);
        glEnable(GL_LIGHT0);
    }


}
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 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;
    }
}

int main(int argc, char *argv[])
{
    cout<<"IDZ DO PRZODU - 'W'"<<endl;
    cout<<"IDZ DO PRZODU - 'S'"<<endl;
    cout<<"SPOJRZ W GORE - 'strzalka w gore'"<<endl;
    cout<<"SPOJRZ W DOL - 'strzalka w dol'"<<endl;
    cout<<"SPOJRZ W LEWO - 'strzalka w lewo'"<<endl;
    cout<<"SPOJRZ W DOL - 'strzalka w prawo'"<<endl;

    rzut =FRUST;
    glutInit(&argc, argv);
    glutInitWindowSize(width,height);
    glutInitWindowPosition(10,10);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

    glutCreateWindow("GLUT Shapes");

    glutReshapeFunc(Reshape);
    glutDisplayFunc(display);
    glutKeyboardFunc(key);
    glutSpecialFunc(SpecialKeys);
    glutIdleFunc(idle);
    glutTimerFunc (1000/60, TimerFunction, 0);
    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("Reflektor", REFLEKTOR);
    glutAddMenuEntry("Swiatlo Ogolne", SWIATLO_OGOLNE);
    glutAddMenuEntry ("Wyjscie",EXIT);
    glutAttachMenu (GLUT_RIGHT_BUTTON);

    glClearColor(0,0,0,1);

    glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);

    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);

    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT1);
    glEnable(GL_NORMALIZE);
    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_LIGHTING);

    glLightfv (GL_LIGHT0, GL_AMBIENT, fSlabe_swiatlo); // œwiat³o otoczenia
    glLightfv (GL_LIGHT0, GL_DIFFUSE, fMocne_swiatlo); // œwiat³o rozproszenia
    glLightfv (GL_LIGHT0, GL_SPECULAR, fMocne_swiatlo); // œwiat³o odbite
    glLightfv (GL_LIGHT0, GL_POSITION, fPozycja_swiatla); // pozycja œwiat³a

    glLightf (GL_LIGHT1, GL_SPOT_CUTOFF, frozwarcie); // reflektor o k¹cie rozwarcia 60 stopni
    glLightf(GL_LIGHT1,GL_SPOT_EXPONENT,fskupienie); // stopieñ skupienia reflektora

    glLightfv (GL_LIGHT1, GL_AMBIENT, fSlabe_swiatlo); // œwiat³o otoczenia
    glLightfv (GL_LIGHT1, GL_DIFFUSE, fMocne_swiatlo); // œwiat³o rozproszenia
    glLightfv (GL_LIGHT1, GL_SPECULAR, fMocne_swiatlo); // œwiat³o odbite
    glLightfv (GL_LIGHT1, GL_POSITION, fPozycja_reflektora); // pozycja œwiat³a
    glLightfv (GL_LIGHT1, GL_SPOT_DIRECTION, fKierunek_reflektora); // kierunek w który odwrócony jest reflektor

glMaterialfv (GL_FRONT, GL_AMBIENT, ambient_materials);
glMaterialfv (GL_FRONT, GL_DIFFUSE, diffuse_materials);
glMaterialfv (GL_FRONT, GL_SPECULAR, specular_materials);
glMateriali (GL_FRONT, GL_SHININESS, shininess_materials);


    glutMainLoop();

    return EXIT_SUCCESS;
}