//---------------------------------------------------------------------
// Ukazkovy priklad k serii clanku OpenGL evaluatorech
//
// Autor:          Pavel Tisnovsky
// Cislo clanku:   9
// Cislo prikladu: 2
//
// Po spusteni tohoto prikladu se vykresli Bezierova bikubicka plocha,
// ktera je vypoctena s pouzitim evaluatoru. Vypocet probiha ve funkci
// drawBezierSurfaceUsingEvaluators(). Bezierova plocha se zobrazi
// pomoci plosek vykreslovanych primitivou GL_QUADS.
// Pro kazdou plosku se automaticky vypocita jeji normalovy vektor,
// ktery je pouzit pri vypoctu osvetleni pomoci Phongova osvetlovaciho
// modelu. Krome vypoctu osvetleni je Bezierova plocha take pokryta
// rastrovou texturou.
// Pohled na Bezierovu plochu je animovany, animaci lze spustit a
// zastavit pomoci klavesy S. Pomoci klavesy A lze zapnout ci vypnout
// automaticke generovani normalovych vektoru.
// Klavesou ESC je mozne program ukoncit, klavesa F prepina zobrazeni
// na celou obrazovku, klavesou W se zobrazeni prepne zpet do okna.
//---------------------------------------------------------------------



#ifdef __BORLANDC__
#include <windows.h>                                // oprava chyby v nekterych Borlandskych prekladacich
#endif

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <GL/glut.h>                                // hlavickovy soubor funkci GLUTu a OpenGL

#ifdef __BORLANDC__
#pragma hdrstop                                     // konec predkompilovanych hlavicek pro Borlandske prekladace
#endif

#define WINDOW_WIDTH    450                         // velikost okna
#define WINDOW_HEIGHT   450
#define WINDOW_LEFT      30                         // pozice leveho horniho rohu okna na desktopu
#define WINDOW_TOP       30
#define WINDOW_TITLE    "OpenGL evaluatory, priklad cislo 9.2" // titulek okna

#define TEXTURE_WIDTH  64                           // sirka textury zadana v texelech
#define TEXTURE_HEIGHT 64                           // vyska textury zadana v texelech

unsigned char texture[TEXTURE_HEIGHT][TEXTURE_WIDTH][4];// pole pro ulozeni pixmapy textury

typedef struct {                                    // novy datovy typ zapouzdrujici velikost okna
    unsigned int    width;
    unsigned int    height;
} Window;

Window window;

GLfloat ctrlPoints[4][4][3] = {                     // ridici body Bezierovy plochy v 3D prostoru
    { {-2.5,-1.5, 4.0}, {-0.5,-1.5, 2.0}, {0.5,-1.5,-1.0}, { 2.5,-1.5, 2.0} },
    { {-2.5,-0.5, 1.0}, {-0.5,-0.5, 3.0}, {0.5,-0.5, 0.0}, { 2.5,-0.5,-1.0} },
    { {-2.5, 0.5, 4.0}, {-0.5, 0.5, 0.0}, {0.5, 0.5, 3.0}, { 2.5, 0.5, 4.0} },
    { {-2.5, 1.5,-2.0}, {-0.5, 1.5,-2.0}, {0.5, 1.5, 0.0}, { 2.5, 1.5,-1.0} }
};

GLfloat texturePoints[2][2][2] = {                  // ridici body Bezierovy plochy v prostoru u-v
    { { 0.0, 0.0}, { 0.0, 1.0}},
    { { 1.0, 1.0}, { 1.0, 0.0}}
};

static float angle1=0;                              // uhel natoceni modelu
static float angle2=0;                              // ve vsech trech osach
static float angle3=0;
static int   animation=1;                           // priznak ridici animaci
static int   autonormal=1;                          // priznak ridici generovani normalovych vektoru



// parametry, ktere ovlivnuji osvetleni
GLfloat materialAmbient[]={0.4f, 0.4f, 0.4f, 1.0f}; // ambientni slozka barvy materialu
GLfloat materialDiffuse[]={0.8f, 0.4f, 0.4f, 1.0f}; // difuzni slozka barvy materialu
GLfloat materialSpecular[]={1.0f, 1.0f, 1.0f, 1.0f};// barva odlesku
GLfloat materialShininess[]={50.0f};                // faktor odlesku
GLfloat light_position[]={1.0f, 1.0f, 1.0f, 0.0f};  // pozice svetla




//---------------------------------------------------------------------
// Vytvoreni rastroveho vzorku pro texturu
//---------------------------------------------------------------------
void makeRasterTexture(void)
{
    int i,j,c;                                      // pocitadla smycek
    unsigned char * P;                              // ukazatel na zapisovany subtexel
    
    for (j=0; j<TEXTURE_HEIGHT; j++) {              // pro vsechny radky pixmapy
        P=texture[j][0];
        for (i=0; i<TEXTURE_WIDTH; i++) {           // pro vsechny texely na radku
            c=((((i&0x08)==0)^((j&0x08))==0)) * 255;
            *P++=(unsigned char)c;                  // zapsat barevne slozky RGB
            *P++=(unsigned char)(i<<2);
            *P++=(unsigned char)(j<<2);
            *P++=(unsigned char)255;                // alfa slozka
        }
    }
}



//---------------------------------------------------------------------
// Tato funkce vykresli Bezierovu plochu pomoci evaluatoru
//---------------------------------------------------------------------
void drawBezierSurfaceUsingEvaluators(
        GLfloat ctrlPoints[][4][3],
        GLfloat texturePoints[][2][2])
{
#define DELENI 20
    int i,j;

    glEnable(GL_MAP2_VERTEX_3);                     // povoleni 2D evaluatoru
    glEnable(GL_MAP2_TEXTURE_COORD_2);              // mapovani textur pomoci evaluatoru
    if (autonormal)
        glEnable(GL_AUTO_NORMAL);                   // automaticky vypocet normalovych vektoru
    else
        glDisable(GL_AUTO_NORMAL);

    // predani ridicich bodu Bezierovy plochy
    glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4,
                              0, 1,12, 4, &ctrlPoints[0][0][0]);

    // predani ridicich bodu pro vypocet textur pomoci evaluatoru
    glMap2f(GL_MAP2_TEXTURE_COORD_2,
                              0, 1, 2, 2,
                              0, 1, 4, 2, &texturePoints[0][0][0]);

    // vykresleni Bezierovy plochy
    glMapGrid2f(DELENI, 0.0f, 1.0f, DELENI, 0.0f, 1.0f);
    glEvalMesh2(GL_FILL, 0, DELENI, 0, DELENI);

    // zakaz aplikace obou typu evaluatoru
    glDisable(GL_MAP2_VERTEX_3);
    glDisable(GL_MAP2_TEXTURE_COORD_2);
}



//---------------------------------------------------------------------
// Funkce pro inicializaci vykreslovani
//---------------------------------------------------------------------
void onInit(void)
{
    // nastaveni vlastnosti framebufferu
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);           // barva pozadi obrazku
    glClearDepth(1.0f);                             // implicitni hloubka ulozena v pameti hloubky
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);                           // povoleni a nastaveni testu hloubky fragmentu

    // styl vykreslovani
    glPointSize(2.0f);                              // velikost vykreslovanych ridicich bodu
    glLineWidth(2.0f);                              // sirka vykreslovanych car
    glEnable(GL_POINT_SMOOTH);                      // povoleni antialiasingu bodu
    glEnable(GL_LINE_SMOOTH);                       // povoleni antialiasingu car
    glShadeModel(GL_SMOOTH);                        // nastaveni Gouraudova stinovani

    // prace s texturou
    makeRasterTexture();                            // vytvoreni vzorku v texure
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);          // zpusob ulozeni bytu v texture
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // opakovani textury
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // volba filtru
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,         // nahrani rastrovych dat do textury
                 TEXTURE_WIDTH, TEXTURE_HEIGHT,
                 0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
    glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);// vylepseni zobrazovani
    glEnable(GL_TEXTURE_2D);                        // povoleni texturovani

    // prace s materialy
    glPolygonMode(GL_FRONT, GL_FILL);               // nastaveni rezimu vykresleni modelu
    glPolygonMode(GL_BACK, GL_FILL);                // jak pro predni tak pro zadni steny
    glDisable(GL_CULL_FACE);                        // zadne hrany ani steny se nebudou odstranovat
    glMaterialfv(GL_FRONT, GL_AMBIENT, materialAmbient);    // nastaveni ambientni slozky barvy materialu
    glMaterialfv(GL_FRONT, GL_DIFFUSE, materialDiffuse);    // nastaveni difuzni slozky barvy materialu
    glMaterialfv(GL_FRONT, GL_SPECULAR, materialSpecular);  // nastaveni barvy odlesku
    glMaterialfv(GL_FRONT, GL_SHININESS, materialShininess);// nastaveni faktoru odlesku
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);      // nasstaveni pozice svetla
    glEnable(GL_LIGHTING);                          // globalni povoleni stinovani
    glEnable(GL_LIGHT0);                            // povoleni prvniho svetla
}



//---------------------------------------------------------------------
// Nastaveni souradneho systemu v zavislosti na velikosti okna
//---------------------------------------------------------------------
void onResize(int w, int h)                         // argumenty w a h reprezentuji novou velikost okna
{
    glViewport(0, 0, (GLsizei)w, (GLsizei)h);       // viditelna oblast pres cele okno
    glMatrixMode(GL_PROJECTION);                    // zacatek modifikace projekcni matice
    glLoadIdentity();                               // vymazani projekcni matice (=identita)

    if (w<=h) {                                     // jestlize je okno nastaveno na vysku
        glOrtho(-5.0, 5.0, -5.0*(GLfloat)h/(GLfloat)w, 5.0*(GLfloat)h/(GLfloat)w, -5.0, 5.0);
    }
    else {                                          // jestlize je okno nastaveno na sirku
        glOrtho(-5.0*(GLfloat)w/(GLfloat)h,5.0*(GLfloat)w/(GLfloat)h, -5.0, 5.0, -5.0, 5.0);
    }
    window.width=w;                                 // zapamatovat si velikost okna
    window.height=h;
    glMatrixMode(GL_MODELVIEW);                     // zacatek modifikace modelove matice
    glLoadIdentity();                               // vymazani modelove matice (=identita)
}



//--------------------------------------------------------------------
// Tato funkce je volana pri kazdem prekresleni okna
//--------------------------------------------------------------------
void onDisplay(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);// smazani barvoveho a Z-bufferu
 
    glMatrixMode(GL_MODELVIEW);                     // bude se menit modelova matice
    glLoadIdentity();                               // vymazat predchozi transformace
    glRotatef(angle1, 0.0, 0.0, 1.0);               // rotace modelu kolem z-ove osy
    glRotatef(angle2, 0.0, 1.0, 0.0);               // rotace modelu kolem y-ove osy
    glRotatef(angle3, 1.0, 0.0, 0.0);               // rotace modelu kolem x-ove osy

    drawBezierSurfaceUsingEvaluators(ctrlPoints, texturePoints); // vykresleni Bezierovy plochy pomoci evaluatoru

    glFlush();                                      // provedeni a vykresleni vsech zmen
    glutSwapBuffers();                              // a prohozeni predniho a zadniho bufferu
}



//---------------------------------------------------------------------
// Tato funkce je volana pri volnem casovem slotu
//---------------------------------------------------------------------
void onIdle(void)
{
    if (animation) {
        angle1++;                                   // zmena uhlu rotace okolo z-ove osy
        angle2+=1.6f;                               // zmena uhlu rotace okolo y-ove osy
        angle3+=2.1f;                               // zmena uhlu rotace okolo x-ove osy
        glutPostRedisplay();                        // prekresleni sceny
    }
}



//---------------------------------------------------------------------
// Tato funkce je volana pri stlaceni ASCII klavesy
//---------------------------------------------------------------------
#ifdef __BORLANDC__
#pragma option -w-par                               // aby Borlandi prekladace nehlasily
#endif                                              // warningy ze argumenty nejsou pouzity
void onKeyboard(unsigned char key, int x, int y)
{
    if (key>='A' && key<='Z')                       // uprava velkych pismen na mala
        key+='a'-'A';                               // pro zjednoduseni prikazu switch

    switch (key) {
        case 27:    exit(0);                break;  // ukonceni aplikace
        case 'q':   exit(0);                break;  // ukonceni aplikace
        case 'f':   glutFullScreen();       break;  // full screen
        case 'w':   glutReshapeWindow(WINDOW_WIDTH, WINDOW_HEIGHT);// prepnuti zpet do okna
                    glutPositionWindow(WINDOW_LEFT, WINDOW_TOP);
                                            break;
        case 's':   animation=!animation;   break;  // zapnuti/vypnuti animace
        case 'a':   autonormal=!autonormal; break;  // zapnuti/vypnuti generovani normalovych vektoru
        default:                            break;
    }
}
#ifdef __BORLANDC__
#pragma option -w+par
#endif



//---------------------------------------------------------------------
// Hlavni funkce konzolove aplikace
//---------------------------------------------------------------------
int main(int argc, char **argv)
{
    glutInit(&argc, argv);                          // inicializace knihovny GLUT
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); // nastaveni dvou barvovych bufferu a pameti hloubky
    glutInitWindowPosition(WINDOW_LEFT, WINDOW_TOP);// pocatecni pozice leveho horniho rohu okna
    glutInitWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);// pocatecni velikost okna
    glutCreateWindow(WINDOW_TITLE);                 // vytvoreni okna pro kresleni
    glutDisplayFunc(onDisplay);                     // registrace funkce volane pri prekreslovani okna
    glutReshapeFunc(onResize);                      // registrace funkce volane pri zmene velikosti okna
    glutKeyboardFunc(onKeyboard);                   // registrace funkce volane pri stlaceni klavesy
    glutIdleFunc(onIdle);                           // registrace funkce volane pri volnem casovem slotu
    onInit();                                       // inicializace vykreslovani
    glutMainLoop();                                 // nekonecna smycka, kde se volaji zaregistrovane funkce
    return 0;                                       // navratova hodnota vracena operacnimu systemu
}



//---------------------------------------------------------------------
// Konec zdrojoveho souboru
//---------------------------------------------------------------------