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

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

#ifndef PI
const double PI = 3.14159265358979323846;
#endif

CGWave::CGWave() {
	run_ = false;
    culling_ = false;
    showNormals_ = false;
    periodAnim_ = false;
	lightAnim_ = false;
    zoom_ = 1.5;
	periode_=0;
	list_ = NULL;
    rot_ = 180.0;
	
	buildPatch(40);
}

CGWave::~CGWave() {
}

static GLfloat light_position1[] = {0.0, 1.0, 0.0, 1.0};  /* Point light location. */    

void CGWave::drawScene() {

	glPushMatrix();
	glRotatef(60,1,0,0);
	glScaled(zoom_, zoom_, zoom_);


    glLightfv(GL_LIGHT1, GL_POSITION, light_position1);
    drawObject();
	// Positionieren bzw. Animieren der Lichtquelle 1
 	

	// draw light source (yellow !)
	glPushMatrix();
	glDisable(GL_LIGHTING);

	// draw vector from light source
	glColor4f(1, 1, 0, 0.5);

	glBegin(GL_LINES);
	glVertex3f(light_position1[0], light_position1[1], light_position1[2]);
	glVertex3f(light_position1[0], 0, light_position1[2]);
	glEnd();
	// translate sphere that represents our light source

	glTranslatef(light_position1[0], light_position1[1], light_position1[2]);
    glutSolidSphere(0.03,10,10);

	glEnable(GL_LIGHTING);
	glPopMatrix();

	glPopMatrix();
}

Vector CGWave::WavedNormal(const Vector& v) const
{
	// get distance, stretch wave length
	double distance = abs(v)*20;
	// add periode shift
	distance += periode_;

	// normalize to [0,2*PI[
//	while (distance >= 2*PI)
//		distance -= 2*PI;

	// normalize point vector
	const Vector v_norm = v.normalized();

	const double cos_dist = cos(distance);
	const double nx = v_norm[0]*cos_dist;
	const double ny = 1; // alternative: sin(distance);	
	const double nz = v_norm[2]*cos_dist;

	return Vector(nx, ny, nz).normalized();
}

void CGWave::handleVertex(const Vector& v) const {
	// compute normal according to wave functions
	glNormal3dv(WavedNormal(v).rep());
	// send vertex
    glVertex3dv(v.rep());
}

void CGWave::drawObject() {
	// draw geometry
	int c=0;
	for(int j=0; j<num_; j++) {
	    glBegin(GL_TRIANGLE_STRIP); // Performance
		// 1)
		handleVertex(list_[c]); c++;
		// 2)
		handleVertex(list_[c]); c++;
		// 3)
		handleVertex(list_[c]); c++;

		for(int i=0; i<((num_+1)*2)-3; i++) {
			// Rest des Strips
			handleVertex(list_[c]); c++;
		}

		glEnd();
	}

	// show normals ?
    if(showNormals_) {
	    glDisable(GL_LIGHTING);

		// lady in red
        glColor3f(1,0,0);
        glBegin(GL_LINES);

		c = 0;
		// process all vertices
		for (int i=0; i<2*num_+2; i++)
			for (int j=0; j<num_; j++)
			{
				// get vertex
				Vector& v = list_[c++];
				// beginning from surface (small offset, though) ...
				glVertex3d (v[0], v[1]+0.01, v[2]);
				// ... to the end which we get by adding (stretched) normal to v
				glVertex3dv((v+(0.1*WavedNormal(v))).rep());
			}

		glEnd();
        glEnable(GL_LIGHTING);
    }
}

void CGWave::buildPatch(int detail) {
	// In Dreiecken tessellierten Fläche
	if(list_) delete list_;

	const int points = (detail)*(4+((detail-1)*2));
	list_ = new Vector[points];

	double offset = 1.0/detail;

	double x;
	double z;
    num_ = detail;
	int c = 0;
	for(int j=0; j<detail; j++) { // passend zu Triangle-Strip (s.o.)
		x = -0.5;
		z =  0.5 - (j+1)*offset;
		list_[c] = Vector(x,0,z); c++;

        x = -0.5;
		z =  0.5 - j*offset;
		list_[c] = Vector(x,0,z); c++;

        x = -0.5 + offset;
		z =  0.5 - (j+1)*offset;
		list_[c] = Vector(x,0,z); c++;

		for(int i=0; i<detail; ) {
			if( (c%2)!=0) {
				x = -0.5 + (i+1)*offset;
				z =  0.5 - (j)*offset;
				i++;
			} else {
				x = -0.5 + (i+1)*offset;
				z =  0.5 - (j+1)*offset;
			}
			list_[c] = Vector(x,0,z); c++;
		}
	}
}

void CGWave::onInit() {
    // OpenGL Lichtquelle 0
	static GLfloat light_diffuse[] = {0.7, 0.8, 0.5, 1.0};
    static GLfloat light_position[] = {0.0, 1.0, 0.0, 1.0};
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);
	// glEnable(GL_LIGHT0); // wenn T&L nicht unterstützt

    // OpenGL Lichtquelle 1
    static GLfloat light_diffuse1[] = {0.7, 0.8, 1.0, 1.0};   /* Diffuse light. */
    static GLfloat light_specular1[] = {0.6, 0.8, 0.6, 1.0};  /* Positional light source */
	glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse1);
    glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular1);
    glLightfv(GL_LIGHT1, GL_POSITION, light_position1);
    glEnable(GL_LIGHT1);

    glEnable(GL_LIGHTING);

	// OpenGL Material 
    static GLfloat mat_specular[] = {0.8, 0.8, 0.8, 1.0};     /* Material property. */
	glMaterialf(GL_FRONT, GL_SHININESS, 32);
	glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);

    // automatische Normalisierung
    glEnable(GL_NORMALIZE);
    
    // Tiefen Test aktivieren
    glEnable(GL_DEPTH_TEST);

	// Blending aktivieren
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
    // Smooth Schattierung aktivieren
    glShadeModel(GL_SMOOTH); 
//    glShadeModel(GL_FLAT); 
    
    // Projection
    glMatrixMode(GL_PROJECTION);
    gluPerspective(60.0, 1.0, 2.0, 50.0);   
    
    // LookAt tesselieren
    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
    
	glRotatef(-25, 0.0, 1.0, 0.0);
    glClearColor(0.9,0.9,0.9,1.0);
}

void CGWave::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 CGWave::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 'q': { glEnable(GL_LIGHT0); break; }
	case 'Q': { glDisable(GL_LIGHT0); break; }
	case 'c': { culling_ = !culling_; break; }
	case 'n': { showNormals_ = !showNormals_; break; }
	case 'p': { periodAnim_ = !periodAnim_; break; }
	case 'y': { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); break;}
	case 'x': { glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); break;}
	case 'l': { lightAnim_ = !lightAnim_; break; }
	case '1': { buildPatch(1); break; }
	case '2': { buildPatch(2); break; }
	case '3': { buildPatch(5); break; }
	case '4': { buildPatch(10); break; }
	case '5': { buildPatch(20); break; }
	case '6': { buildPatch(40); break; }
	case '7': { buildPatch(50); break; }
	case '8': { buildPatch(100); break; }
	case '9': { buildPatch(200); break; } // netter Versuch
    }
    onDraw();
}

void CGWave::onIdle() {
    if(periodAnim_) 
	{ // Periodische Wellenbewegung
		periode_ -= 0.05;
	    if (periode_  < 0 ) 
		    periode_ += 2*PI;
    }

    if(lightAnim_)
	{
		rot_+=2; // Animierte Lichtquellen

		// slow down rotation
		double slow_rot = rot_/3;
		light_position1[0] = 0.5*cos(slow_rot*PI/180.0);
		light_position1[1] = 0.5;
		light_position1[2] = 0.5*sin(slow_rot*PI/180.0);
	}
  
	if (run_)  // Simple Rotation
        glRotatef(.5, 0.0, 1.0, 0.0);

	// Redraw
	onDraw();
}

void CGWave::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:
    CGWave sample;

    cout << "Tastenbelegung:" << endl
		 << "ESC        Programm beenden" << endl
		 << "Leertaste  Objekt drehen" << endl
		 << "+          Hineinzoomen" << endl
		 << "-          Herauszoomen" << endl
		 << "n          Normalen anzeigen/verbergen" << endl
		 << "p          Wellen animieren an/aus" << endl
		 << "l          Lichtquelle bewegen" << endl
		 << "q          zweite Lichtquelle an" << endl
		 << "Q          zweite Lichtquelle aus" << endl
		 << "y          Drahtgittermodell" << endl
		 << "x          Flaechen ausfuellen" << endl
		 << "1 bis 9    Tessellationsgrad (1 - ungenau, schnell   9 - sehr exakt, langsam)" << endl;         
    
    // Starte die Beispiel-Anwendung:
    sample.start("Stephan Brumme, 702544", true, 512, 512);
    return(0);
}