//
// Computergraphik II
// Prof. Dr. Juergen Doellner
// Wintersemester 2001/02
// 
// Rahmenprogramm zu Aufgabenzettel 3
//

#include "cginterpolation.h"
#include "vector.h"
#include <fstream.h>
#include <stdlib.h>

CGInterpolation::CGInterpolation() {
    run_ = false;
    zoom_ = 0.15;
	culling_ = false;

	max_ = 100;                    // maximale Laenge des Arrays
	counter_ = 0;                  // Anzahl der Vertices
	list_ = new Vector[max_];      // Array mit Vertices
	ref_ = Vector(8.0, -1.0, 1.0); // Referenzpunkt

	loadGeometry();                // Import der Geometriedaten
}

CGInterpolation::~CGInterpolation() {
}

void CGInterpolation::drawScene() {

	glPushMatrix();
	glScaled(zoom_, zoom_, zoom_);

    static GLuint cache = 0;
    if (cache == 0) {
        cache = glGenLists(1); // Display-Liste
        glNewList(cache, GL_COMPILE_AND_EXECUTE); // Display-Liste

		glColor3f(0.5, 0.4, 0.4);
		drawObject(ref_);

		glMatrixMode(GL_MODELVIEW);
		glPushMatrix();
		glTranslatef(ref_[0],ref_[1],ref_[2]);
	
		glColor3f(0.9, 0.1, 0.2);
		glutSolidSphere(0.1,16,16);
		glPopMatrix();

        glEndList(); // Display-Liste
    } else {                        
        glCallList(cache); // Display-Liste
    }    

	glPopMatrix();
}

void CGInterpolation::drawObject(const Vector& ref) {
	// draw geometry

	// normieren Sie Ihre Abstandsfunktion
	double dMaxDistance = 0;
	double dMinDistance = 999999999999;
	for(unsigned int i=0; i<counter_; i++) 
	{
		double* pVector  = list_[i].rep();
		double dDistance = sqrt(((pVector[0] - ref_[0]) * (pVector[0] - ref_[0])) +
			                    ((pVector[1] - ref_[1]) * (pVector[1] - ref_[1])) +
    						    ((pVector[2] - ref_[2]) * (pVector[2] - ref_[2])));

		if (dDistance > dMaxDistance)
			dMaxDistance = dDistance;
		if (dDistance < dMinDistance)
			dMinDistance = dDistance;
	}


	// Zeichnen Sie die Dreiecke mit Farbwerten an den Vertices.
	glBegin(GL_TRIANGLES);
	for(i=0; i<counter_; i++) {

		double* pVector  = list_[i].rep();
		double dDistance = sqrt(((pVector[0] - ref_[0]) * (pVector[0] - ref_[0])) +
			                    ((pVector[1] - ref_[1]) * (pVector[1] - ref_[1])) +
						        ((pVector[2] - ref_[2]) * (pVector[2] - ref_[2])));
		double dNormalized = (dDistance - dMinDistance) / (dMaxDistance - dMinDistance);

		glColor3d(dNormalized, dNormalized, dNormalized);
		glVertex3dv(list_[i].rep());

	}
    glEnd();

}

void CGInterpolation::loadGeometry() {
	//ifstream s("small.txt");
    ifstream s("stegarosaurus.txt");
    //ifstream s("triceratops.txt");
	
    char buf[100];                

    while (!s.eof()) {
        s >> buf;
        
        while (s.good()) {            
		    Vector v0;        
		    Vector v1;        
		    Vector v2;        
            s >> v0 >> v1 >> v2;
			if(counter_+3 >= max_) {
				max_*=2;
				Vector* newList = new Vector[max_];
				for(unsigned int i=0; i<counter_; i++) {
					newList[i] = list_[i];
				}
				delete list_;
				list_ = newList;
			}
			list_[counter_] = v0; counter_++;
			list_[counter_] = v1; counter_++;
			list_[counter_] = v2; counter_++;
        }
        if (s.rdstate() & ios::failbit) {
            s.clear(s.rdstate() & ~ios::failbit);                                         
        }
    }
}

void CGInterpolation::onInit() {
    
    // automatische Normalisierung
    glEnable(GL_NORMALIZE);
    
    // Tiefen Test aktivieren
    glEnable(GL_DEPTH_TEST);
    
    // Smooth Schattierung aktivieren
    glShadeModel(GL_SMOOTH);
    
    // Projection
    glMatrixMode(GL_PROJECTION);
    gluPerspective(60.0,1.0,2,100.0);   
    
    // LookAt
    glMatrixMode(GL_MODELVIEW);
    gluLookAt(
		0.0, 0.0, 4.0,  // from (0,0,4) 
        0.0, 0.0, 0.0,  // to (0,0,0) 
        0.0, 1.0, 0.);  // up
    
    glClearColor(0.9,0.9,0.9,1.0);
}

void CGInterpolation::onSize(unsigned int newWidth,unsigned int newHeight) {          
    width_ = newWidth;
    height_ = newHeight;            
    glMatrixMode(GL_PROJECTION);
    glViewport(0, 0, width_ - 1, height_ - 1);        
    glLoadIdentity();
    gluPerspective(40.0,float(width_)/float(height_),2.0, 100.0);
    glMatrixMode(GL_MODELVIEW);     
}

void CGInterpolation::onKey(unsigned char key) {
    switch (key) {
    case 27: { exit(0); break; }                        
    case '+': { zoom_*= 1.1; break; }
    case '-': { zoom_*= 0.9; break; }
    case ' ': { run_ = !run_; break; }
	case 'c': { culling_ = !culling_; break; }
    }
    onDraw();
}

void CGInterpolation::onIdle() {  
    if (run_) {
        glRotatef(1, 0.0, 1.0, 0.0);         
        onDraw();
    }
}

void CGInterpolation::onDraw() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);                

	if (culling_) glEnable(GL_CULL_FACE);

	drawScene();

	glDisable(GL_CULL_FACE);

    // Nicht vergessen! Front- und Back-Buffer tauschen:
    swapBuffers();
}

// Hauptprogramm
int main(int argc, char* argv[]) {
    // Erzeuge eine Instanz der Beispiel-Anwendung:
    CGInterpolation sample;
    
    cout << "Tastenbelegung:" << endl
		 << "ESC        Programm beenden" << endl
		 << "Leertaste  Objekt drehen" << endl
		 << "+          in die Szene hineinzoomen" << endl
		 << "-          aus der Szene herauszoomen" << endl
		 << "c          Culling de-/aktivieren" << endl;

   // Starte die Beispiel-Anwendung:
    sample.start("Stephan Brumme, 702544", true, 512, 512);
    return(0);
}