#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <float.h>
#include <GL/glut.h>         /* glut.h includes gl.h and glu.h*/

#define PI 3.141592
#define NX 32
#define NY 32
#define ST_DEN 4
#define FULL_ST 4
#define MAX_GEN 128

//the number of the object being moved (0 if none)
int WHeight = 640;
int WWidth = 640;

//for detecting doubleclicks
time_t clickTime;
int clickX = -1;
int clickY = -1;

//remember mouse position
int mouseX;
int mouseY;

//program modes
int addingGen = 0;
int currentElement = 0;

//display options
int option;
int displayArrows = 0;
int displayBackground = 0;
int displayStreams = 0;
int displayGen = 0;
int displayGrid = 0;
int bothWays = 0;

//modes
int mode1 = 0;

// track keyboard actions
int keys[256] = {0};

// Define gridsize
float VF[NX][NY][2];
float T[NX][NY];

// Field generators
float Gen[MAX_GEN][4];
int GenSize = 0;

float Wing[9][2];

//function declarations
void setProjection();
void display();
void init();
void drawArrow(float a, float d);
void shepard(float x, float y, float *v);
void shepard2(float T, float x, float y, float *v);
void generateField();
void normalizeField();
void drawGenArrow(float a, float d);
void calculateTurbulance(); 
void pick (int x, int y);
void drawWing();
void loadMode1();

//calculate norms
float dist2(float x, float y) {
	return x*x+y*y;
} 

float dist(float x, float y) {
	return sqrt(dist2(x, y));
}

float pos(float f) {
	return (f<0) ? -f : f;
}

//gets color from velocity
void setColor(float v, float alpha) {
    if (v<0.25) {
    	glColor4f(0.0, v/0.25, 1.0, alpha);
    } else if (v<0.5) {
        glColor4f(0.0, 1.0, 2-v/0.25, alpha);
    } else if (v<0.75) {
        glColor4f(v/0.25-2, 1.0, 0.0, alpha);
    } else {
    	glColor4f(1, 4-v/0.25, 0.0, alpha);
    }
}

void setColorLoop(float v, float alpha) {
	float dc = 1./6;
    if (v<dc) {
    	glColor4f(0.0, v/dc, 1.0, alpha);
    } else if (v<2*dc) {
        glColor4f(0.0, 1.0, 2-v/dc, alpha);
    } else if (v<3*dc) {
        glColor4f(v/dc-2, 1.0, 0.0, alpha);
    } else if (v<4*dc) {
        glColor4f(1.0, 4-v/dc, 0.0, alpha);
    } else if (v<5*dc) {
        glColor4f(1.0, 0.0, v/dc-5, alpha);
    } else {
    	glColor4f(6-v/dc, 0.0, 1.0, alpha);
    }
}

void addGen(float x0, float y0, float x1, float y1) {
	//printf("addGen\n");
	if (GenSize<MAX_GEN) {
		Gen[GenSize][0] = x0;
		Gen[GenSize][1] = y0;
		Gen[GenSize][2] = x1;
		Gen[GenSize][3] = y1;
		GenSize++;
	}
	generateField();
	calculateTurbulance();
}

void deleteGen(int n) {
	if (GenSize>0) {
		int i,j;
		for (i=n;i<GenSize-1;i++) {
			for (j=0;j<4;j++) {
				Gen[i][j] = Gen[i+1][j];
			}
		}
		GenSize--;
	}
	generateField();
	calculateTurbulance();
}

void resetField() {
	int i,j;
	GenSize = 0;
	for (i=0;i<NX;i++) {
		for (j=0;j<NY;j++) {
			VF[i][j][0] = 0;
			VF[i][j][1] = 0;
			T[i][j] = 0;
		}
	}
	//addGen(0.0, 0.0, 0.01, 0.0);
}

void normalizeField() {
	int i,j;
	float max=0, d=0;
	for (i=0;i<NX;i++) {
		for (j=0;j<NY;j++) {
			d = dist(VF[i][j][0], VF[i][j][1]);
			max =  (max>d) ? max : d;
		}
	}
	if (max!=0) {
		for (i=0;i<NX;i++) {
			for (j=0;j<NY;j++) {
				VF[i][j][0] *= 1./max;
				VF[i][j][1] *= 1./max;
				//printf("N=%f\n",dist(VF[i][j][0], VF[i][j][1]));
			}
		}
	}
}

void generateField() {
	int i,j;	
	//printf("generateField\n");
	for (i=0;i<NX;i++) {
		for (j=0;j<NY;j++) {
			shepard((float)i/NX, (float)j/NY, VF[i][j]);
			//printf("v[%d][%d]=[%f,%f]\n",i,j,VF[i][j][0],VF[i][j][1]);
		}
	}
	normalizeField();
	//printf("generateField - done\n");
}

void generateField2(float T) {
	int i,j;	
	//printf("generateField\n");
	for (i=0;i<NX;i++) {
		for (j=0;j<NY;j++) {
			shepard2(T,(float)i/NX, (float)j/NY, VF[i][j]);
			//printf("v[%d][%d]=[%f,%f]\n",i,j,VF[i][j][0],VF[i][j][1]);
		}
	}
	normalizeField();
	//printf("generateField - done\n");
}

void normalizeTurbulance() {
	int i,j;
	float max=0;
	for (i=0;i<NX;i++) {
		for (j=0;j<NY;j++) {
			max =  (max>T[i][j]) ? max : T[i][j];
		}
	}
	if (max!=0) {
		for (i=0;i<NX;i++) {
			for (j=0;j<NY;j++) {
				T[i][j] *= 1./max;
			}
		}
	}
}

void calculateTurbulance() {
	int i,j;
	for (i=1;i<NX-1;i++) {
		for (j=1;j<NY-1;j++) {
			T[i][j] = pos((VF[i][j+1][0]-VF[i][j-1][0])*(VF[i+1][j][1]-VF[i-1][j][1])
				 	+ (VF[i][j+1][1]-VF[i][j-1][1])*(VF[i+1][j][0]-VF[i-1][j][0]));
				//printf("T(%d %d) = %f\n",i,j,T[i][j]);
		}
	}
	normalizeTurbulance();
}

void shepard(float x, float y, float *v) {
	int i;
	//printf("shepard - [%f, %f]\n",v[0],v[1]);
	float w=0, C=1;
	float res[2] = {0, 0};
	for (i=0;i<GenSize;i++) {
		if (dist2(x-Gen[i][0], y-Gen[i][1])==0) {
			res[0] = Gen[i][2]-Gen[i][0];
			res[1] = Gen[i][3]-Gen[i][1];
			C = 1;
			break;
		} else {
			w = 1./dist2(x-Gen[i][0], y-Gen[i][1]);	
			res[0] += w*(Gen[i][2]-Gen[i][0]);
			res[1] += w*(Gen[i][3]-Gen[i][1]);
			C += w;
		}
	}
	v[0] = res[0]/C;
	v[1] = res[1]/C;
	//printf("%d:[%f %f]\n",i,v[0],v[1]);
}

void shepard2(float T, float x, float y, float *v) {
	int i;
	//printf("shepard - [%f, %f]\n",v[0],v[1]);
	float w=0, C=1;
	float res[2] = {0, 0};
	for (i=0;i<GenSize;i++) {
		if ((Gen[i][1]-T)*(y-T)>0) {
			if (dist2(x-Gen[i][0], y-Gen[i][1])==0) {
				res[0] = Gen[i][2]-Gen[i][0];
				res[1] = Gen[i][3]-Gen[i][1];
				C = 1;
				break;
			} else {
				w = 1./dist2(x-Gen[i][0], y-Gen[i][1]);	
				res[0] += w*(Gen[i][2]-Gen[i][0]);
				res[1] += w*(Gen[i][3]-Gen[i][1]);
				C += w;
			}
		}
	}
	v[0] = res[0]/C;
	v[1] = res[1]/C;
	printf("%d:[%f %f]\n",i,v[0],v[1]);
}

void drawStream(float x, float y, float h) {
	//printf("drawStream - [%f %f %f]\n", x, y, h);
	if (GenSize!=0) {
		int i, stop = 0;
		float v[2] = {0, 0};
		float d;
		float bx=x, by=y;
		glBegin(GL_LINE_STRIP);
			for (i=0; stop==0 && i<10000; i++) {
				glLineWidth(i/5);
				if (x!=NX && y!=NY) {
					shepard(x,y,v);
				} else {
					stop = 1;
				}
				glVertex2f(x, y);
				d = dist(v[0],v[1]);
				if (d!=0)  {
					x += v[0]*h/d;
					y += v[1]*h/d;
				}
				if (x<=0 || x>=1 || y<=0 || x>=1 || d<0.001) {
					stop = 1;
				}
			}
		glEnd();
		if (bothWays==1) {
			glBegin(GL_LINE_STRIP);
				for (i=0, stop = 0; stop==0 && i<10000; i++) {
					if (bx!=NX && by!=NY) {
						shepard(bx,by,v);
					} else {
						stop = 1;
					}
					glVertex2f(bx, by);
					d = dist(v[0],v[1]);
					if (d!=0)  {
						bx -= v[0]*h/d;
						by -= v[1]*h/d;
					}
					if (bx<=0 || bx>=1 || by<=0 || bx>=1 || d<0.001) {
						stop = 1;
					}
				}
			glEnd();
		}	
	}
	//printf("drawStream - done\n");
}

void drawStreams(float h) {
	//glLineWidth(2);
	int i;
	glColor4f(0.01, 0.01, 0.01, 0.8);
	for (i=0;i<NX;i+=ST_DEN) {
		drawStream((float)i/NX,0,h);
		drawStream((float)(i+ST_DEN/2)/NX,1,h);
		drawStream(0,(float)(i+ST_DEN/2)/NY,h);
		drawStream(1,(float)i/NY,h);
	}
	//glLineWidth(1);
}

void drawFullStream(float h) {
	//printf("fullStream\n");
	int P = 5;
	glLineWidth(P);
	int i;
	for (i=0;i<WWidth;i++) {
		setColorLoop(((float)((i*2*FULL_ST)%WWidth))/WWidth, 0.7/P);
		drawStream((float)2*i/WWidth,0,h);
		setColorLoop(((float)((i*2*FULL_ST)%WWidth))/WWidth, 0.7/P);
		drawStream((float)(2*i+1)/WWidth,1,h);
		setColorLoop(((float)((i*2*FULL_ST)%WHeight))/WHeight, 0.7/sqrt(P));
		drawStream(0,(float)2*i/WHeight,h);
		setColorLoop(1-((float)((i*2*FULL_ST)%WHeight))/WHeight, 0.7/P);
		drawStream(1,(float)(2*i+1)/WHeight,h);
	}
	glLineWidth(1);
}

void drawGen() {
	int i;
	//printf("drawGen\n");
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	float a, d;
	for (i=0;i<GenSize;i++) {
		//printf("%d: [%f, %f, %f, %f]\n",i, Gen[i][0], Gen[i][1], Gen[i][2], Gen[i][3]);
		glLoadName(i+1);
		d = dist(Gen[i][0]-Gen[i][2],Gen[i][1]-Gen[i][3]);
		if ((Gen[i][2]-Gen[i][0])==0) {
			a = ((Gen[i][3]-Gen[i][1])>0) ? PI/2 : -PI/2;
		} else {
			a = atan((Gen[i][3]-Gen[i][1])/(Gen[i][2]-Gen[i][0]));
			a = ((Gen[i][2]-Gen[i][0])<=0) ? PI+a : a;
		}
		glPushMatrix();
			glLineWidth(2);	
			glTranslatef(Gen[i][0], Gen[i][1], 0);
			glColor4f(0.01, 0.01, 0.01, 0.7);
			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
			drawGenArrow(a, d);
			glColor4f(0.99, 0.99, 0.99, 0.99);
			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
			drawGenArrow(a, d);
			glLineWidth(1);
		glPopMatrix();
	}
	//printf("drawGen - done\n");
}

void drawRubberGen(float x, float y) {
	//printf("drawRubberGen - %f %f %f %f\n",Gen[GenSize][0],Gen[GenSize][1],x,y);
	float a, d = dist(Gen[GenSize][0]-x,Gen[GenSize][1]-y);
	if ((x-Gen[GenSize][0])==0) {
		a = ((y-Gen[GenSize][1])>0) ? PI/2 : -PI/2;
	} else {
		a = atan((y-Gen[GenSize][1])/(x-Gen[GenSize][0]));
		a = ((x-Gen[GenSize][0])<=0) ? PI+a : a;
	}
	glPushMatrix();
		glLineWidth(2);
		glTranslatef(Gen[GenSize][0], Gen[GenSize][1], 0);
		glColor4f(0.01, 0.01, 0.01, 0.7);
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
		drawGenArrow(a, d);
		glColor4f(0.99, 0.99, 0.99, 0.99);
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
		drawGenArrow(a, d);
		glLineWidth(1);
	glPopMatrix();
}

void drawGrid() {
	int i;
	glColor4f(0.1, 0.1, 0.1, 0.4);
	for (i=0;i<NX;i++) {
		glBegin(GL_LINES);
			glVertex2f((float)i/NX,0.0);
			glVertex2f((float)i/NX,1.0);
		glEnd();
	}
	for (i=0;i<NY;i++) {
		glBegin(GL_LINES);
			glVertex2f(0.0, (float)i/NX);
			glVertex2f(1.0, (float)i/NX);
		glEnd();	
	}
}

void drawArrow(float a, float d) {
	glPushMatrix();
		glRotatef(a*180/PI,0,0,1);
		glScalef(d,d,1);	
		glBegin(GL_LINES);
			glVertex2f(0,0);
			glVertex2f(1,0);
		glEnd();
		glBegin(GL_POLYGON);
			glVertex2f(1,0);
			glVertex2f(0.6,0.2);
			glVertex2f(0.6,-0.2);
		glEnd();
	glPopMatrix();
}

void drawGenArrow(float a, float d) {
	//glLineWidth(3);
	glPushMatrix();
		glRotatef(a*180/PI,0,0,1);
		glPushMatrix();
			glScalef(d, 1, 1);
			glBegin(GL_POLYGON);
				glVertex2f(0.0,0.005);
				glVertex2f(0.97,0.005);
				glVertex2f(0.97,-0.005);
				glVertex2f(0.0,-0.005);
			glEnd();
		glPopMatrix();
		glPushMatrix();
			glTranslatef(0.97*d,0,0);
			glBegin(GL_POLYGON);
				glVertex2f(0.0,0.02);
				glVertex2f(0.03,0.0);
				glVertex2f(0.0,-0.02);
			glEnd();
		glPopMatrix();
	glPopMatrix();
	//glLineWidth(1);
}

void gridArrows() {
	glColor4f(0.1,0.1,0.1,0.6);
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	int i,j;
	float a, d;
	for (i=0; i<NX; i++) {
		for (j=0; j<NY; j++) {
			d = dist(VF[i][j][0],VF[i][j][1]);
			a = (VF[i][j][0]==0) ? PI/2 : atan(VF[i][j][1]/VF[i][j][0]);
			a = (VF[i][j][0]<=0) ? PI+a : a;
			glPushMatrix();
				glTranslatef((float)i/NX, (float)j/NY, 0);
				drawArrow(a, 0.2*d);
			glPopMatrix();
		}
	}
}

void gridNormalArrows() {
	glColor4f(0.1,0.1,0.1,0.7);
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	int i,j;
	float a;
	//glTranslatef(1/Nx, 1/NY, 0);
	for (i=0; i<NX; i++) {
		for (j=0; j<NY; j++) {
			//glColor4f(0.1,0.1,0.1,sqrt(Vel(i,j,K,0)*Vel(i,j,K,0)+Vel(i,j,K,1)*Vel(i,j,K,1)));
			a = (VF[i][j][0]==0) ? PI/2 : atan(VF[i][j][1]/VF[i][j][0]);
			a = (VF[i][j][0]<=0) ? PI+a : a;
			glPushMatrix();
				glTranslatef((float)i/NX, (float)j/NY, 0);
				drawArrow(a, 1./NX);
			glPopMatrix();
		}
	}
}

void gridTurbBG() {
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	int i,j;
	float alpha = 0.6;
	for (i=0; i<NX; i++) {
		for (j=0; j<NY; j++) {
			glPushMatrix();
				glTranslatef((float)i/NX, (float)j/NY, 0);
				glScalef(1./NX, 1./NY, 1);
				glBegin(GL_POLYGON);
					setColor(T[i][j],alpha);
					glVertex2f(0,0);
					setColor(T[(i+1)%NX][j],alpha);
					glVertex2f(1,0);
					setColor(T[(i+1)%NX][(j+1)%NY],alpha);
					glVertex2f(1,1);
					setColor(T[i][(j+1)%NX],alpha);
					glVertex2f(0,1);
				glEnd();
			glPopMatrix();
		}
	}
}

void gridPressBG() {
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	int i,j;
	for (i=0; i<NX; i++) {
		for (j=0; j<NY; j++) {
			glPushMatrix();
				glTranslatef((float)i/NX, (float)j/NY, 0);
				glScalef(1./NX, 1./NY, 1);
				glBegin(GL_POLYGON);
					setColor(dist2(VF[i][j][0], VF[i][j][1]),0.6);
					glVertex2f(0,0);
					setColor(dist2(VF[(i+1)%NX][j][0], VF[(i+1)%NX][j][1]), 0.6);
					glVertex2f(1,0);
					setColor(dist2(VF[(i+1)%NX][(j+1)%NY][0], VF[(i+1)%NX][(j+1)%NY][1]), 0.6);
					glVertex2f(1,1);
					setColor(dist2(VF[i][(j+1)%NY][0], VF[i][(j+1)%NY][1]), 0.6);
					glVertex2f(0,1);
				glEnd();
			glPopMatrix();
		}
	}
}

void display (void) {        
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    setProjection();
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
	if (displayBackground==1) {
		gridPressBG();
	} else if (displayBackground==2) {
		drawFullStream(0.01);
	} else if (displayBackground==3) {
		gridTurbBG();
	}
	if (displayGrid==1) {
		drawGrid();
	}
	if (displayStreams==1) {
		drawStreams(0.01);
	};
	if (displayArrows==1) {
		gridArrows();
	} else if (displayArrows==2) {
		gridNormalArrows();
	}
	if (displayGen==1) {
		drawGen();
		}   
	if (mode1==1) {
		drawWing();
	}
	if (addingGen==1) {
		drawRubberGen((float)mouseX/WWidth, (float)mouseY/WHeight);
	}
    glFlush();
}

void initWing() {
	Wing[0][0] = 10;
	Wing[0][1] = 6;
	Wing[1][0] = 11;
	Wing[1][1] = 8;
	Wing[2][0] = 13;
	Wing[2][1] = 10;
	Wing[3][0] = 17;
	Wing[3][1] = 10;
	Wing[4][0] = 37;
	Wing[4][1] = 5;
	Wing[5][0] = 25;
	Wing[5][1] = 5;
	Wing[6][0] = 21;
	Wing[6][1] = 4;
	Wing[7][0] = 13;
	Wing[7][1] = 4;
	Wing[8][0] = 11;
	Wing[8][1] = 5;
}

void initWingGen() {
	//printf("initWingGen\n");
	int i;
	for (i=0; i<48; i++, GenSize++) {
		Gen[i][0] = (float)(i%12)/12;
		Gen[i][1] = (float)(i/12)/12 + 0.35;
		Gen[i][2] = Gen[i][0]+1;
		Gen[i][3] = Gen[i][1];
		//printf("%d: [%f, %f, %f, %f]\n",i, Gen[i][0], Gen[i][1], Gen[i][2], Gen[i][3]);
	}
	Gen[15][2] -= 1.;
	Gen[16][2] -= 1.;
	Gen[17][2] -= 1.;
	Gen[18][2] -= 1.;
	Gen[19][2] -= 1.;
	Gen[28][2] -= 1.;
	
	float lx, ly;
	for (i=0; i<4; i++, GenSize++) {
		lx = (Wing[(8+i)%9][0]-Wing[(7+i)%9][0])/60;
		ly = (Wing[(8+i)%9][1]-Wing[(7+i)%9][1])/60;
		Gen[GenSize][0] = Wing[(7+i)%9][0]/60+lx/2;
		Gen[GenSize][1] = Wing[(7+i)%9][1]/60+ly/2+0.35;
		Gen[GenSize][2] = Gen[GenSize][0]-ly/dist(lx, ly);
		Gen[GenSize][3] = Gen[GenSize][1]+lx/dist(lx, ly);
		//printf("%d: [%f, %f, %f, %f]\n",i, Gen[GenSize][0], Gen[GenSize][1], Gen[GenSize][2], Gen[GenSize][3]);
	}
	for (i=0; i<5; i++, GenSize++) {
		lx = (Wing[(8+i)%9][0]-Wing[(7+i)%9][0])/60;
		ly = (Wing[(8+i)%9][1]-Wing[(7+i)%9][1])/60;
		Gen[GenSize][0] = Wing[(6+i)%9][0]/60;
		Gen[GenSize][1] = Wing[(6+i)%9][1]/60+0.35;
		Gen[GenSize][2] = Gen[GenSize][0]-ly/dist(lx, ly);
		Gen[GenSize][3] = Gen[GenSize][1]+lx/dist(lx, ly);
		//printf("%d: [%f, %f, %f, %f]\n",i, Gen[GenSize][0], Gen[GenSize][1], Gen[GenSize][2], Gen[GenSize][3]);
	}
	lx = (Wing[3][0]-Wing[4][0])/60;
	ly = (Wing[3][1]-Wing[4][1])/60;
	for (i=0;i<11;i++, GenSize++) {
		Gen[GenSize][0] = (Wing[3][0]+i*2)/60;
		Gen[GenSize][1] = (Wing[3][1]-(float)i*0.5)/60+0.35;
		Gen[GenSize][2] = Gen[GenSize][0]-0.5*ly/dist(lx, ly);
		Gen[GenSize][3] = Gen[GenSize][1]+0.5*lx/dist(lx, ly);
	}
	for (i=0;i<3;i++, GenSize++) {
		Gen[GenSize][0] = (Wing[6][0]+i*2)/60;
		Gen[GenSize][1] = (Wing[6][1]+(float)i*0.5)/60+0.35;
		Gen[GenSize][2] = Gen[GenSize][0]-0.5*ly/dist(lx, ly);
		Gen[GenSize][3] = Gen[GenSize][1]-0.5*lx/dist(lx, ly);
	}
	for (i=0;i<7;i++, GenSize++) {
		Gen[GenSize][0] = (Wing[5][0]+i*2)/60;
		Gen[GenSize][1] = (Wing[5][1])/60+0.35;
		Gen[GenSize][2] = Gen[GenSize][0];
		Gen[GenSize][3] = Gen[GenSize][1]+0.5;
	}
	//printf("initWingGen - done\n");
}

void drawWing() {
	//printf("drawWing\n");
	int i;
	//glLineWidth(2);
	glPushMatrix();
		//glTranslatef(-0.1, 0.28, 0.0);
		//glScalef(1./40, 1./40, 1);
		glTranslatef(0.0, 0.35, 0.0);
		glScalef(1./60, 1./60, 1);
		glColor4f(0.99, 0.99, 0.99, 0.99);
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);	
		glBegin(GL_POLYGON);
			for (i=0; i<9; i++) {
				glVertex2f(Wing[i][0], Wing[i][1]);
				//printf("[%f %f]\n",Wing[i][0], Wing[i][1]);
			}
		glEnd();
		
		glColor4f(0.01, 0.01, 0.01, 0.99);
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);	
		glBegin(GL_POLYGON);
			for (i=0; i<9; i++) {
				glVertex2f(Wing[i][0], Wing[i][1]);
				//printf("[%f %f]\n",Wing[i][0], Wing[i][1]);
			}
		
		glEnd();
	glPopMatrix();
	//printf("drawWing - done\n");
}

void setProjection(void) {
	glMatrixMode (GL_PROJECTION);
	glLoadIdentity ();
	glOrtho(0, 1.0, 0, (float)NY/NX, -10.0, 10.0);
}

void mouseClick (int button, int state, int x, int y) {
	y = WHeight - y;
    if ((button==GLUT_LEFT_BUTTON) && (state==GLUT_DOWN)) {
		if (GenSize<MAX_GEN) {
			addingGen = 1;
			Gen[GenSize][0] = (float)x/WWidth;
			Gen[GenSize][1] = (float)y/WHeight;
		}
	} else if ((button==GLUT_LEFT_BUTTON) && (state==GLUT_UP)) {
		if (addingGen==1) {
			if (dist(Gen[GenSize][0]-(float)x/WWidth, Gen[GenSize][1]-(float)y/WHeight) > 0.001) {
				addGen(Gen[GenSize][0], Gen[GenSize][1],(float)x/WWidth, (float)y/WHeight);
				//printf("GenSize=%d\n",GenSize);
			}
		}
		addingGen = 0;
	} else if ((button==GLUT_RIGHT_BUTTON) && (state==GLUT_DOWN)) {
		addingGen = 0;
		pick(x, y);
		if (currentElement!=0) {
			deleteGen(currentElement-1);
		}
		currentElement = 0;
	} else if ((button==GLUT_RIGHT_BUTTON) && (state==GLUT_UP)) {
		addingGen = 0;
	} else if ((button==GLUT_MIDDLE_BUTTON) && (state==GLUT_DOWN)) {
		
	} else if ((button==GLUT_MIDDLE_BUTTON) && (state==GLUT_UP)) {
		
	}
	mouseX = x;
	mouseY = y;
	display();
}

void mouseMove (GLint x, GLint y) {
	y = WHeight - y;
	mouseX = x;
	mouseY = y;
	display();
}

void passiveMouseMove (GLint x, GLint y) {
    y = WHeight - y;
}

void keyboardDown (unsigned char key, int x, int y) {
    //printf("key: %d\n",key);
    keys[key] = 1;
    switch (key) {
    	case 114: // r - restart
    		init();
            break;
        case 27 : // escape - quit
            exit(0);
            break;
        case 97 : // a - display arrows
            displayArrows = (displayArrows+1)%3;
            break;
        case 98 : // b - display background
            displayBackground = (displayBackground+1)%4;
            break;
        case 103 : // g - display generators
            displayGrid = (displayGrid+1)%2;
            break;
        case 118 : // v - display generators
            displayGen = (displayGen+1)%2;
            break;
        case 115 : // s - display streams
            displayStreams = (displayStreams+1)%2;
            break;
        case 119 : // s - load wing 1
            loadMode1();
    }
    display();
}

void keyboardUp (unsigned char key, int x, int y) {
    printf("key: %d\n",key);
    keys[key] = 0;
}

void pick (int x, int y) {
    GLuint buff[64] = {0};
 	GLint hits, view[4];
 	glSelectBuffer(64, buff);
 	glGetIntegerv(GL_VIEWPORT, view);
 	glRenderMode(GL_SELECT);
 	glInitNames();
 	glPushName(0);
 	glMatrixMode(GL_PROJECTION);
 	glPushMatrix();
 		glLoadIdentity();
 		gluPickMatrix(x, y, 1.0, 1.0, view);
 		glOrtho(0, 1.0, 0, 1.0, -10., 10.);
 		glMatrixMode(GL_MODELVIEW);
 		glFlush();
 		printf("addingGen %d\n",addingGen);
 		display();
 	glPopMatrix();
 	hits = glRenderMode(GL_RENDER);
 	currentElement = (GLubyte)buff[4*(hits-1)+3];
 	printf("pick: %d\n",currentElement);
 	glMatrixMode(GL_MODELVIEW);
}

void reshape(int w, int h){
	int m = (w<h) ? w : h;
	WHeight=m;
	WWidth=m;
	glViewport(0,0, (GLsizei) h, (GLsizei) h);
    glMatrixMode (GL_PROJECTION);
    glLoadIdentity ();
	glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void loadMode1() {
	init();
	mode1 = 1;
	resetField();
	initWing();
	printf("1\n");
	initWingGen();
	printf("2\n");
	generateField2(0.45);
	printf("3\n");
	calculateTurbulance();
	displayGen = 0;
	displayGrid = 0;
	displayArrows = 2;
	displayStreams = 0;
	displayBackground = 1;
	display();
}

void init() {
 	glEnable(GL_LINE_SMOOTH);
 	glClearColor (1, 1, 1, 1);
	setProjection();
	
	//polygons
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	
	//antialising
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glDisable(GL_LINE_SMOOTH);
	
	//shading
	glShadeModel(GL_SMOOTH);
	
	//initialize fields
	resetField();
	
	//reset modes
	addingGen = 0;
	currentElement = 0;
	
	// display options
	displayArrows = 0;
	displayBackground = 0;
	displayStreams = 0;
	displayGen = 1;
	displayGrid = 1;
	
	//modes
	mode1 = 0;
	
    display();
}
 
void handle_main_menu(int item) {
    option = item;
}

void handle_arrow_menu(int item) {
    displayArrows = item;
}

void handle_bg_menu(int item) {
    displayBackground = item;
}

void handle_stream_menu(int item) {
    displayStreams = item;
}

void handle_integration_menu(int item) {
    bothWays = item;
}

void handle_grid_menu(int item) {
    displayGrid = item;
}

int main (int argc, char **argv) {
    glutInit(&argc,argv); 
	glutInitDisplayMode(GLUT_RGB|GLUT_SINGLE);
	glutInitWindowSize(WWidth, WHeight);
	glutInitWindowPosition(0,0); 
	glutCreateWindow("Flow Viewer"); 
	glutDisplayFunc(display);
	glutKeyboardFunc(keyboardDown);
	glutKeyboardUpFunc(keyboardUp);
	glutMouseFunc(mouseClick);
	glutMotionFunc(mouseMove);
	glutReshapeFunc(reshape);
	glutPassiveMotionFunc(passiveMouseMove);
	
	int gridMenu = glutCreateMenu(handle_grid_menu);
		glutAddMenuEntry("hide", 0);
		glutAddMenuEntry("show", 1);
	glutAttachMenu(GLUT_RIGHT_BUTTON);
	
	int arrowMenu = glutCreateMenu(handle_arrow_menu);
		glutAddMenuEntry("hide", 0);
		glutAddMenuEntry("show real values", 1);
		glutAddMenuEntry("show normalized", 2);
	glutAttachMenu(GLUT_RIGHT_BUTTON);
	
	int bgMenu = glutCreateMenu(handle_bg_menu);
		glutAddMenuEntry("none", 0);
		glutAddMenuEntry("pressure", 1);
		glutAddMenuEntry("turbulance", 3);
		glutAddMenuEntry("continuous streams", 2);
	glutAttachMenu(GLUT_RIGHT_BUTTON);
		
	int streamMenu = glutCreateMenu(handle_stream_menu);
		glutAddMenuEntry("hide", 0);
		glutAddMenuEntry("show", 1);
	glutAttachMenu(GLUT_RIGHT_BUTTON);
	
	int integrationMenu = glutCreateMenu(handle_integration_menu);
		glutAddMenuEntry("forward", 0);
		glutAddMenuEntry("both ways", 1);
	glutAttachMenu(GLUT_RIGHT_BUTTON);
	
	glutCreateMenu(handle_main_menu);
		glutAddSubMenu("grid off", gridMenu);
		glutAddSubMenu("Vectors", arrowMenu);
		glutAddSubMenu("Colormap", bgMenu);
		glutAddSubMenu("Streamlines", streamMenu);
		glutAddSubMenu("Integration", integrationMenu);		
    glutAttachMenu(GLUT_RIGHT_BUTTON);
      
	init();
	glutMainLoop();
	
	return EXIT_SUCCESS;
}