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

#include "cgcontour.h"
#include "vector.h"


// degree of tessellation
const int    PATCHSIZE =  100;
// range of x,z
const double MINIMUM   = -2.0;
const double MAXIMUM   = +2.0;
const double SPAN      = MAXIMUM - MINIMUM;
const double DELTA     = SPAN/(PATCHSIZE-1);

// store values of the function
bool calculationdone = false;
double arPatch[PATCHSIZE][PATCHSIZE];
// correspending normals
Vector arNormals[PATCHSIZE][PATCHSIZE];



CGContour::CGContour() {
	run_ = false;
	normals_ = false;
    zoom_ = 0.4;
}

CGContour::~CGContour() {
}  

void CGContour::drawScene() {

	glPushMatrix();

		glRotated(30, 1.0, 0.0, 0.0);
		glScaled(zoom_, zoom_, zoom_);

		// Achsen
		glLineWidth(3.0);
		glColor3f(0.0, 0.0, 0.0);
		
		glDisable(GL_LIGHTING);
		glBegin(GL_LINES);
		glVertex3f( 0.0, 0.0, 0.0);
        glVertex3f( 3.0, 0.0, 0.0);
        glVertex3f( 0.0, 0.0, 0.0);
        glVertex3f( 0.0, 6.0, 0.0);
        glVertex3f( 0.0, 0.0, 0.0);
        glVertex3f( 0.0, 0.0, 3.0);
		glEnd();
		glEnable(GL_LIGHTING);

		// Licht 1
	    static GLfloat light_diffuse[] = {1.0, 1.0, 1.0, 1.0};      //  diffuse light
		static GLfloat light_position[]= {0.0, 1.0, 0.0, 0.0};      //  infinite light location
            
		glLightfv(GL_LIGHT1, GL_DIFFUSE,  light_diffuse );
	    glLightfv(GL_LIGHT1, GL_POSITION, light_position);

		// Funktion
		drawFunction();

	glPopMatrix();
}

void CGContour::drawFunction() {
    // Hier die Funktion zeichnen.

	// perform calculation only once
	if (!calculationdone)
	{
		for (int x=0; x<PATCHSIZE; x++)
			for (int z=0; z<PATCHSIZE; z++)
			{
				const double x_coord = MINIMUM + x*DELTA;
				const double z_coord = MINIMUM + z*DELTA;

				// f(x,z) = x^2 - z^2
				arPatch[x][z]   = x_coord*x_coord - z_coord*z_coord; 

				// f(x,z)/dx = 2x-z^2
				// f(x,z)/dz = x^2-2z
				// normal = crossproduct((0,f/dz,1), (1,f/dx,0))
				arNormals[x][z] = (Vector(0, x_coord*x_coord-2*z_coord, 1) * 
					               Vector(1, 2*x_coord-z_coord*z_coord, 0)).normalized();
			}

		// function doesn't change
		calculationdone = true;
	}

	// define texture projection plane (object space !)
	static GLfloat xz_plane[] = { 0.0, 1.0, 0.0, 0.0 };
	glTexGeni (GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
	glTexGenfv(GL_S, GL_OBJECT_PLANE, xz_plane);
	
	// enable automatic 1D texturing
	glEnable(GL_TEXTURE_GEN_S);
	glEnable(GL_TEXTURE_1D);

	// display function
	for (int x=1; x<PATCHSIZE; x++)
	{
		// one triangle strip per row
		glBegin(GL_TRIANGLE_STRIP);

		// draw one row (as a triangle strip)
		for (int z=0; z<PATCHSIZE; z++)
		{
			const double x_coord = MINIMUM + x*DELTA;
			const double z_coord = MINIMUM + z*DELTA;

			// left border of the row
			glNormal3dv(arNormals[x-1][z].rep());
			glVertex3d(x_coord-DELTA, arPatch[x-1][z], z_coord);

			// right border of the row
			glNormal3dv(arNormals[x  ][z].rep());
			glVertex3d(x_coord      , arPatch[x  ][z], z_coord);
		}

		glEnd();
	}
	glDisable(GL_TEXTURE_1D);

	// draw normals if necessary
	if (normals_)
	{
		// no lighting
		glDisable(GL_LIGHTING);

		// draw all normals
		for (x=1; x<PATCHSIZE; x++)
		{
			glLineWidth(1);
			glColor3f(1,0,0);
			glBegin(GL_LINES);

			for (int z=0; z<PATCHSIZE; z++)
			{
				const double x_coord = MINIMUM + x*DELTA;
				const double z_coord = MINIMUM + z*DELTA;

				// short normals for better visualization
				Vector normal = arNormals[x][z] * 0.2;

				glVertex3d(x_coord, arPatch[x][z], z_coord);
				glVertex3d(x_coord+normal[0], arPatch[x][z]+normal[1], z_coord+normal[2]);
			}

			glEnd();
		}
		glEnable(GL_LIGHTING);
	}
}

void CGContour::createTexture() {
    // prozedural eine Textur erzeugen
	for (int i=0; i<TEXTURE_SIZE; i++)
	{
		image_[i*3+0] = 100;
		image_[i*3+1] = (i*255)/TEXTURE_SIZE;
		image_[i*3+2] = 100;
	}

	// represents y = -2, -1, 0, +1, +2 etc.
	image_[0] = image_[1] = image_[2] = 255;


	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	// generate a unique ID
	glGenTextures  (1, &texName_);
	// use this texture ID
	glBindTexture  (GL_TEXTURE_1D, texName_);

	// repeat texture if necessary
	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	// use filter "linear" both for magnification and minification
	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexEnvf      (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,  GL_MODULATE);
	// bind image to texture object
	glTexImage1D   (GL_TEXTURE_1D, 0, GL_RGB, TEXTURE_SIZE, 
		                           0, GL_RGB, GL_UNSIGNED_BYTE, image_);
}

void CGContour::onInit() {
    
    // Tiefen Test aktivieren
    glEnable(GL_DEPTH_TEST);
    
    // Smooth Schattierung aktivieren
    glShadeModel(GL_SMOOTH);
    
    // Projection
    glMatrixMode(GL_PROJECTION);
    gluPerspective(40.0, 1.0, 1.0, 20.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.8, 0.9, 1.0, 0.0);

    createTexture();

	// set lights
    static GLfloat light_position[]= {0.0, 0.0, 1.0, 0.0};
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);

    glEnable(GL_LIGHT0); light0_ = true;
    glEnable(GL_LIGHT1); light1_ = true;

    glEnable(GL_LIGHTING);

    static float material_diffuse[]= {0.6, 0.6, 0.6, 1.0};
    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, material_diffuse);
}

void CGContour::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 CGContour::onKey(unsigned char key) {
    switch (key) {
    case 27: { exit(0); break; }                        
    case '+': { zoom_*= 1.1; break; }
    case '-': { zoom_/= 1.1; break; }
    case ' ': { run_ = !run_; break; }
	case '1': { if (light0_) glDisable(GL_LIGHT0);
				else         glEnable (GL_LIGHT0);
				light0_ = !light0_;
				break; };
	case '2': { if (light1_) glDisable(GL_LIGHT1);
				else         glEnable (GL_LIGHT1);
				light1_ = !light1_; 
				break; };
	case 'n': { normals_ = !normals_; break; }
    }
    onDraw();
}

void CGContour::onIdle() {

    if (run_) {
        glRotatef(.5, 0.0, 1.0, 0.0);
    }
	onDraw();
}

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

	drawScene();

    swapBuffers();
}

// Hauptprogramm
int main(int argc, char* argv[]) {
    // Erzeuge eine Instanz der Beispiel-Anwendung:
    CGContour sample;
    
    cout << "Tastenbelegung:" << endl
		 << "ESC        Programm beenden" << endl
		 << "Leertaste  Objekt drehen" << endl
		 << "1          starre Lichtquelle an/aus" << endl
		 << "2          rotierende Lichtquelle an/aus" << endl
		 << "+          Hineinzoomen" << endl
		 << "-          Herauszoomen" << endl
		 << "n          Normalen zeichnen an/aus" << endl;

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