//
// Computergraphik I
// Prof. Dr. Juergen Doellner
// Sommersemester 2001
// 
// Rahmenprogramm fuer Aufgabenzettel 4
//

// Stephan Brumme, 702544
// last changes: May 20, 2001

#include "cgtessellator.h"

// Function Makro
#if defined(__GNUC__) && !defined(__STRICT_ANSI__)
#define FUNC GLvoid(*)(...)
#elif defined(_MSC_VER)
#define FUNC void(__stdcall*)()
#else
#define FUNC GLvoid(*)()
#endif

// GLU tesselator globale Hilfsfunktionen

// Fehler abfangen
void CALLBACK error(GLenum err) {
    cerr << gluErrorString(err) << endl;    
}

// Schnitt von Kanten, nimmt keine Änderungen vor
void CALLBACK combineCallback(GLdouble coords[3], 
                              GLdouble *vertex_data[4],
                              GLfloat weight[4], GLdouble **dataOut )
{
    GLdouble* vertex = new GLdouble[3];
    vertex[0] = coords[0];
    vertex[1] = coords[1];
    vertex[2] = coords[2];       
    *dataOut = vertex;
}

// stellt Ecke dar
void CALLBACK vertexCallback(GLvoid *vertex)
{
    glVertex3dv((GLdouble*)vertex);
}

// beginnt ein Primitv
void CALLBACK beginCallback(GLenum which)
{
    glBegin(which);
}

// beendet ein Primitiv
void CALLBACK endCallback()
{
    glEnd();
}


// CGTessellator
CGTessellator::CGTessellator() {  
    // Anlegen des TessObj  
    tobj_ = gluNewTess();
    gluTessProperty(tobj_, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD);

    // Datenstruktur initialisieren
    pos_ = 0;
    contours_ = 1;
    contourSize_[0] = 0;
}

CGTessellator::~CGTessellator() {
    // Zerstoeren des TessObj       
    gluDeleteTess(tobj_);
}

// Setze Punkte fuer einen Stern
void CGTessellator::defineStar() {
    // 5 Punkte insgesamt
    pos_ = 5;
    // 1 Kontur
	contours_ = 1;
    // diese Kontur enthält alle bisher definierten Punkte
    contourSize_[0] = 5;
	pts_[0] = Point(150.0, 150.0);
	pts_[1] = Point(225.0, 300.0);
	pts_[2] = Point(300.0, 150.0);
	pts_[3] = Point(150.0, 250.0);
	pts_[4] = Point(300.0, 250.0);

    // Stern zeichnen
    glutPostRedisplay();
}

void CGTessellator::onInit() {
    glClearColor(1, 1, 1, 1);  

    // festlegen der Vertex, Begin, End und Error Callback
    // Beispiel: Combine Callback, Achtung: FUNC-Cast!
    gluTessCallback(tobj_, GLU_TESS_COMBINE, (FUNC) &combineCallback);
    gluTessCallback(tobj_, GLU_TESS_VERTEX, (FUNC) &vertexCallback);


    gluTessCallback(tobj_, GLU_TESS_BEGIN, (FUNC) &beginCallback);
    gluTessCallback(tobj_, GLU_TESS_END, (FUNC) &endCallback);

    gluTessCallback(tobj_, GLU_TESS_ERROR, (FUNC) &error);
}

void CGTessellator::drawPolygon() {
    gluTessBeginPolygon(tobj_, NULL);

    // alle Punkte durchlaufen
    int nVertexPtr = 0;

    // alle Polygone
    for (int nContour = 0; nContour < contours_; nContour++)
    {
        gluTessBeginContour(tobj_);

        // alle Eckpunkte eines Polygons
        for (int nVertex=0; nVertex<contourSize_[nContour]; nVertex++)
        {
            gluTessVertex(tobj_, pts_[nVertexPtr].dta_, pts_[nVertexPtr].dta_);
            nVertexPtr++;
        }

        gluTessEndContour(tobj_);
    }
    gluTessEndPolygon(tobj_);
    // Tessellation des Polygons mit GLU-Routinen    
}

void CGTessellator::onDraw() {
    glClear(GL_COLOR_BUFFER_BIT);

    // Zeichnen des Polygons (blau)
    glColor3f(0.5,0.5,1);
    drawPolygon();

    // Zeichnen des Polygon-Randes (schwarz), benutzt erneut Tessellator
    glColor3f(0,0,0);
    gluTessProperty(tobj_, GLU_TESS_BOUNDARY_ONLY, GL_TRUE);
    drawPolygon();
    gluTessProperty(tobj_, GLU_TESS_BOUNDARY_ONLY, GL_FALSE);

    // Zeichnen der Eckpunkte (rot)
	glPointSize(4);
    glColor3d(1,0,0);

    glBegin(GL_POINTS);
    for (int i = 0; i < pos_; i++) 
        glVertex2dv(pts_[i].dta_);
    glEnd();
    
    // tauschen wie im Swingerclub
    swapBuffers();
}

void CGTessellator::onSize(unsigned int newWidth, unsigned int newHeight) {
    glClear(GL_COLOR_BUFFER_BIT);
    glViewport(0, 0, newWidth - 1, newHeight - 1);
    
    glMatrixMode(GL_PROJECTION_MATRIX);
    glLoadIdentity();
    gluOrtho2D(0, newWidth-1, 0, newHeight-1);
    glMatrixMode(GL_MODELVIEW_MATRIX);  
    
}

void CGTessellator::onKey(unsigned char key) {   
    // Key Belegung
    switch (key) {
        // beenden
    case 'q': exit(0); break;

        // Stern zeichnen
    case 's': defineStar(); break;

        // neue Kontur beginnen
    case 'k': contourSize_[contours_++] = 0; break;

        // alle Punkte/Bildschirm löschen
    case 'c': contours_ = 1;
              contourSize_[0] = 0;
              pos_ = 0;
              break;

        // Tessellationsalgorithmen
    case '1': gluTessProperty(tobj_, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ODD); break;
    case '2': gluTessProperty(tobj_, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_NONZERO); break;
    case '3': gluTessProperty(tobj_, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_POSITIVE); break;
    case '4': gluTessProperty(tobj_, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_NEGATIVE); break;
    case '5': gluTessProperty(tobj_, GLU_TESS_WINDING_RULE, GLU_TESS_WINDING_ABS_GEQ_TWO); break;
    }

    // und neu zeichnen
    glutPostRedisplay();
}

void CGTessellator::onButton(MouseButton button, MouseButtonEvent event, 
                            int x, int y) {    
    // Punkt speichern
	pts_[pos_] = Point(x, y);
    contourSize_[contours_-1]++;
    pos_++;

    // und neu zeichnen
    glutPostRedisplay();
}

int main(int argc, char* argv[]) {
    CGTessellator tess;
    tess.start(argc, argv, "CGTessellator, Stephan Brumme, 702544",
        CGTessellator::ColorBuffer| CGTessellator::DoubleBuffer | CGTessellator::StencilBuffer,
        200, 400, 400);
    return(0);
}