zadani5_4

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

using namespace std;

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

int rzut,skala;
static int slices = 32;
static int stacks = 32;

int wcisk = 0;

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

GLdouble eyex=0.0;
GLdouble eyey=0.0;
GLdouble eyez=1.0;

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

GLdouble fovy =45;


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

    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(-1, 1, -1.0, 1.0, 2.0, 100.0);
    //glOrtho(-ar, ar, -1.0, 1.0, 2.0, 100.0);
    gluLookAt(eyex,eyey,eyez,pointx,pointy,pointz,0,1,0);

    //glMatrixMode(GL_MODELVIEW);
    //glLoadIdentity() ;
}
*/
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);
    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();
        glColor3d(1,1,0);
        glTranslated(0,0,-6);
        glutSolidSphere(3.5,slices,stacks);//Slonce
        glPushMatrix();
            glColor3d(0,0.5,1);
            glRotated(a/12,0,1,0);
            glTranslated(0.0,0.0,14.0);
            glScaled(1.0,1.03,1.0);
            glRotated(123,1,0,0);
            glRotated(a*30.4,0,0,-1);
            glutSolidSphere(0.4,slices,stacks);//Ziemia
            glPushMatrix();
                glColor3d(1,1,1);
                glRotated((a*30.4)+a,0,0,1);
                glTranslated(0,1,0);
                glutSolidSphere(0.1,slices,stacks);//Ksiezyc
            glPopMatrix();
        glPopMatrix();
        glPushMatrix();
            glColor3d(0,1,0);
            //glTranslated(0.0,2.0,16.0);
            glTranslated(0.0,0.0,16.0);
            //glRotated(a/12,0,1,0);
            glRotated(90,1,0,0);
            glutSolidSphere(0.5,slices,stacks);//Nowa Planeta
            glPushMatrix();
                glColor3d(1,0,0);
                glScaled(1,1,0.3);
                glTranslated(0.0,0.0,0.2);
                glRotated(60,1,0,0);
                glRotated(-a,0,0,1);
                glutSolidTorus(0.1,0.8,slices,stacks);//Pierscien 1
            glPopMatrix();
            glPushMatrix();
                glColor3d(0,1,1);
                glScaled(1,1,0.3);
                glTranslated(0.0,0.0,-0.2);
                glRotated(-60,1,0,0);
                glRotated(a,0,0,1);
                glutSolidTorus(0.1,0.8,slices,stacks);// pierscien 2
            glPopMatrix();
        glPopMatrix();
    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 '-' :
            eyez+=0.1;
            xyzoka();
            xyzcentrum();
        break;
        case '+' :
            eyez-=0.1;
            xyzoka();
            xyzcentrum();
        break;
        case '1' :
            fovy-=0.1;
        break;
        case '2' :
            fovy+=0.1;
        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;
        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;
        skok_eye = 0.0f;
        break;


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

void SpecialKeys( int key, int x, int y )
{
    switch( key )
    {
    case GLUT_KEY_LEFT:
        alfa -= PI / 32;
        pointx = skok_point * cos (alfa) + eyex;
        pointz = skok_point * sin (alfa) + eyez;
        break;
    case GLUT_KEY_RIGHT:
        alfa += PI / 32;
        pointx = skok_point * cos (alfa) + eyex;
        pointz = skok_point * sin (alfa) + eyez;
        break;
    case GLUT_KEY_UP:
        alfa += PI / 32;
        pointy = skok_point * cos (alfa) + eyey;
        pointz = skok_point * sin (alfa) + eyez;
        break;
    case GLUT_KEY_DOWN:
        alfa -= PI / 32;
        pointy = skok_point * cos (alfa) + eyey;
        pointz = skok_point * sin (alfa) + eyez;
        break;
    }

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

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)
    {
// wyjœcie
    case EXIT:
        exit (0);
    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;
    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 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[])
{
    rzut =FRUST;
    glutInit(&argc, argv);
    glutInitWindowSize(640,480);
    glutInitWindowPosition(10,10);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

    glutCreateWindow("GLUT Shapes");

    glutReshapeFunc(Reshape);
    glutDisplayFunc(display);
    glutKeyboardFunc(key);
    glutSpecialFunc(SpecialKeys);
    glutIdleFunc(idle);
    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 ("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_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);
    */
    glutMainLoop();

    return EXIT_SUCCESS;
}