#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <Math.h>
#include <GL/glut.h>

const int N_mnt=60;
const int N_lago=70;
const float coeff=0.5;
const float media_x=0.0;
const float media_z=0.0;
const float dev_std_x=4.0;
const float dev_std_z=4.0;

#define PI 3.141592654
#define E 2.718281828

typedef struct{
	float x,y,z;
} point3D;

point3D viewer,n; 
point3D norm;
float montagna[N_mnt][N_mnt];
float lago[N_lago][N_lago];
int i,j;
GLfloat light_position[]={0.0,15.0,0.0,1.0};

point3D pto1,pto2,pto3,pto4;

int fillMode;

float gauss(float a,float b)
{
	float risultato;
	risultato = 1.0/(2.0*PI*dev_std_x*dev_std_z)*exp(-0.5*(pow(((a-media_x)/dev_std_x),2)+pow(((b-media_z)/dev_std_z),2)));
	return risultato;
}

inline void calcolaColoreVerticeMontagna(float y)
{
	glEnable(GL_BLEND);
	if(y>=8.5)
		glColor4f(1.0,1.0,1.0,1.0);
	else
		if(y>=7.0)
			glColor4f(0.8,0.8,0.8,1.0);
		else
			if(y>=5.0)
				glColor4f(0.437,0.336,0.235,1.0);
			else
				if(y>=4.0)
					glColor4f(0.487,0.387,0.287,1.0);
				else
					
						glColor4f(0.637,0.537,0.437,1.0);
}

inline void calcolaColoreVerticeLago(float y)
{
	if(y<=-0.2)
		glColor4f(0.0,0.2,0.8,0.6);
	else
		if(y<=0.1)
			glColor4f(0.0,0.5,0.5,0.6);
		else
			if(y<=0.4)
				glColor4f(0.0,0.7,0.9,0.6);
}

void calcolaMontagna(float height)
{
		for(i=0;i<N_mnt;i++)
		for(j=0;j<N_mnt;j++)
		{
			montagna[i][j]=height*gauss(i/(float)(N_mnt-1)*(2.0*dev_std_x+12.0) - (dev_std_x+6.0),
											j/(float)(N_mnt-1)*(2.0*dev_std_z+12.0) - (dev_std_z+6.0))+coeff*((float)rand()/RAND_MAX);
//			montagna[i][j]=height*gauss(i/(float)(N_mnt-1)*(10.0*dev_std_x) - (5.0*dev_std_x),
//											j/(float)(N_mnt-1)*(10.0*dev_std_z) - (5.0*dev_std_z))+coeff*((float)rand()/RAND_MAX);
////			printf("montagna[%d][%d]: %f ",i,j,montagna[i][j]);
		}
}

void calcolaLago(void)
{
	for(i=0;i<N_lago;i++)
		for(j=0;j<N_lago;j++)
		{
			lago[i][j]=(sin(i/(float)(N_lago-1)*30.0 - 15.0)*
						cos(j/(float)(N_lago-1)*30.0 - 15.0))/2.0;
		}
}

void normal(point3D *p)
{

// normalize a vector 

    float d =0.0;
	d+=p->x*p->x;
	d+=p->y*p->y;
	d+=p->z*p->z;
    d=sqrt(d);
    if(d>0.0)
	{
		p->x/=d;
		p->y/=d;
		p->z/=d;
	}
}


point3D cross(point3D a,point3D b,point3D c,point3D d)
{
	d.x=(b.y-a.y)*(c.z-a.z)-(b.z-a.z)*(c.y-a.y);
	d.y=(b.z-a.z)*(c.x-a.x)-(b.x-a.x)*(c.z-a.z);
	d.z=(b.x-a.x)*(c.y-a.y)-(b.y-a.y)*(c.x-a.x);
	normal(&d);
	return d;
} 

void disegna_montagna(float larghezza,float profondita,float spostam_x,float spostam_y,float spostam_z)
{
	
	for(i=0;i<N_mnt-1;i++)
	{
		glBegin(GL_QUAD_STRIP);
		//glBegin(GL_LINE_STRIP);
		for(j=0;j<N_mnt-1;j++)
		{
			
			pto1.x = i/(float)(N_mnt-1)*(2.0*dev_std_x+larghezza)-(dev_std_x+larghezza/2)+spostam_x;
			pto1.y=montagna[i][j]+spostam_y;
			pto1.z=j/(float)(N_mnt-1)*(2.0*dev_std_z+profondita)-(dev_std_z+profondita/2)+spostam_z;

			pto2.x=i/(float)(N_mnt-1)*(2.0*dev_std_z+larghezza)-(dev_std_x+larghezza/2)+spostam_x;
			pto2.y=montagna[i][j+1]+spostam_y;
			pto2.z=(j+1)/(float)(N_mnt-1)*(2.0*dev_std_z+profondita)-(dev_std_z+profondita/2)+spostam_z;

			pto3.x=(i+1)/(float)(N_mnt-1)*(2.0*dev_std_z+larghezza)-(dev_std_x+larghezza/2)+spostam_x;
			pto3.y=montagna[i+1][j+1]+spostam_y;
			pto3.z=(j+1)/(float)(N_mnt-1)*(2.0*dev_std_z+profondita)-(dev_std_z+profondita/2)+spostam_z;

			pto4.x=(i+1)/(float)(N_mnt-1)*(2.0*dev_std_z+larghezza)-(dev_std_x+larghezza/2)+spostam_x;
			pto4.y=montagna[i+1][j]+spostam_y;
			pto4.z=j/(float)(N_mnt-1)*(2.0*dev_std_z+profondita)-(dev_std_z+profondita/2)+spostam_z;

		
			//norm=cross(pto1,pto2,pto3,norm);
			//x_norm = norm.x;
			//y_norm = norm.y;
			//z_norm = norm.z;

			point3D  cp1,cp2,cp3,cp4;


			cp1 = pto1;
			cp2 = pto2;
			cp3 = pto3;
			cp4 = pto4;


			normal(&pto1);
			//glNormal3f(x_norm, y_norm, z_norm);
			glNormal3f(pto1.x, pto1.y, pto1.z);
			calcolaColoreVerticeMontagna(montagna[i][j]);
			glVertex3f(cp1.x,cp1.y,cp1.z);

			normal(&pto4);
			glNormal3f(pto4.x,pto4.y,pto4.z);
			calcolaColoreVerticeMontagna(montagna[i+1][j]);
			glVertex3f(cp4.x,cp4.y,cp4.z);

			normal(&pto2);
			glNormal3f(pto2.x,pto2.y,pto2.z);
			calcolaColoreVerticeMontagna(montagna[i][j+1]);
			glVertex3f(cp2.x,cp2.y,cp2.z);

			normal(&pto3);
			glNormal3f(pto3.x,pto3.y,pto3.z);
			calcolaColoreVerticeMontagna(montagna[i+1][j+1]);
			glVertex3f(cp3.x,cp3.y,cp3.z);
		
		}
		glEnd();
	}

}
void keys(unsigned char key,int x,int y)
{
	switch(key)
	{

	case 'x':	
		viewer.x -= 1.0; 
		glutPostRedisplay();
		break;

	case'X':	
		viewer.x += 1.0; 
		glutPostRedisplay();
		break;
	case'y':
		viewer.y -= 1.0; 
		glutPostRedisplay();
		break;
	case'Y':
		viewer.y += 1.0; 
		glutPostRedisplay();
		break;
	case'z':
		viewer.z -= 1.0; 
		glutPostRedisplay();
		break;
	case'Z':
		viewer.z += 1.0; 
		glutPostRedisplay();
		break;
	
	}

}

void myInit()
{

	GLfloat mtn_ambuse[]={0.476,0.376,0.276,1.0};
	GLfloat mtn_specular[]={0.694,0.572,0.467,1.0};
	GLfloat mtn_diffuse[]={0.476,0.376,0.276,1.0};
	GLfloat mtn_shininess[]={10.0};

	glEnable(GL_BLEND);
	GLfloat lago_ambuse[]={0.4,0.4,0.4,0.2};
	GLfloat lago_specular[]={1.0,1.0,1.0,0.2};
	GLfloat lago_diffuse[]={0.0,0.5,0.5,0.2};
	GLfloat lago_shininess[]={90.0};

	GLfloat light_ambient[]={0.8,0.8,0.2,1.0};
	GLfloat light_diffuse[]={0.5,0.5,0.5,1.0};
	GLfloat light_specular[]={0.7,0.7,0.7,1.0};
	GLfloat direzione[]={0.0,-1.0,0.0,0.0};
	
	GLfloat lmodel_ambient[]={0.7,0.7,0.7,1.0};

	//glDepthFunc(GL_LEQUAL);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_NORMALIZE);
	glEnable(GL_COLOR_MATERIAL);
	glShadeModel(GL_SMOOTH);
	glEnable(GL_LIGHTING);
//	glLightf(GL_LIGHTING,GL_CONSTANT_ATTENUATION,0.9);
	glEnable(GL_LIGHT0);
	glLightModelfv(GL_LIGHT_MODEL_AMBIENT,lmodel_ambient);

	glNewList(1,GL_COMPILE);
	glLightfv(GL_LIGHT0,GL_AMBIENT,light_ambient);
	glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse);
	glLightfv(GL_LIGHT0,GL_SPECULAR,light_diffuse);
	glLightfv(GL_LIGHT0,GL_POSITION,light_position);
	glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);
	glLightfv(GL_LIGHT0,GL_SPOT_DIRECTION,direzione);
	glLightf(GL_LIGHT0,GL_SPOT_EXPONENT,32.0);
	glLightf(GL_LIGHT0,GL_SPOT_CUTOFF,40.0);
//	glLightf(GL_LIGHT0,GL_CONSTANT_ATTENUATION,0.5);


	glEndList();

	glNewList(2,GL_COMPILE);
	glEnable(GL_LIGHTING);
		glShadeModel(GL_SMOOTH);
		glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,mtn_ambuse);
		glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,mtn_specular);
		glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,mtn_diffuse);
		glMaterialfv(GL_FRONT_AND_BACK,GL_SHININESS,mtn_shininess);
	glEndList();

	glNewList(3,GL_COMPILE);
	glEnable(GL_LIGHTING);
		glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT,lago_ambuse);
		glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,lago_specular);
		glMaterialfv(GL_FRONT_AND_BACK,GL_DIFFUSE,lago_diffuse);
		glMaterialfv(GL_FRONT_AND_BACK,GL_SHININESS,lago_shininess);
	glEndList();


	fillMode = 1;
}


void display()
{
//	glViewport(0,0,500,500);

	srand(time(NULL));

	glClearColor(0.0,0.0,0.6,1.0);
	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

//	glMatrixMode(GL_PROJECTION);
//	glLoadIdentity();
//	gluPerspective(40,1,0.1,2000.0);
//	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
//	gluLookAt(2,2,7,2,0,0,0,1,0);
	gluLookAt(viewer.x,viewer.y,viewer.z,0,2.0,0,0,1,0);

	glCallList(1);

	glColor4f(1.0,1.0,1.0,1.0);
	glPushAttrib(GL_ALL_ATTRIB_BITS);
	glPushMatrix();
		GLfloat emission[]={0.4,0.4,0.0,1.0};
		glMaterialfv(GL_FRONT_AND_BACK,GL_EMISSION,emission);
		glTranslatef(light_position[0], light_position[1], light_position[2]);
		glutSolidSphere(0.4,18,18);
	glPopMatrix();
	glPopAttrib();


	if(fillMode)
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	else	
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);



//disegno gli assi

/*	glBegin(GL_LINES);
		glColor3f(1.0,0.0,0.0);
		glVertex3f(0.0, 0.0, 0.0);
		glVertex3f(10.0, 0.0, 0.0);

		glColor3f(0.0,1.0,0.0);
		glVertex3f(0.0, 0.0, 0.0);
		glVertex3f(0.0, 10.0, 0.0);

		glColor3f(0.0,0.0,1.0);
		glVertex3f(0.0, 0.0, 0.0);
		glVertex3f(0.0, 0.0, -10.0);
	glEnd();
*/


//	glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);

	glPushAttrib(GL_ALL_ATTRIB_BITS);
		glCallList(2);
		calcolaMontagna(1300.0);
		disegna_montagna(10.0,10.0,-7.0,0.0,-15.0);
		calcolaMontagna(600.0);
		disegna_montagna(10.0,8.0,8.0,0.0,-15.0);
		calcolaMontagna(1000.0);
		disegna_montagna(2.0,20.0,12.0,0.0,-2.0);
		calcolaMontagna(800.0);
		disegna_montagna(2.0,14.0,-10.0,0.0,2.0);
	glPopAttrib();

	glPushAttrib(GL_ALL_ATTRIB_BITS);
	//adesso disegno il lago
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
	glCallList(3);
	glDepthMask(GL_FALSE);

	calcolaLago();
	for(i=0;i<N_lago-1;i++)
	{
		glBegin(GL_QUAD_STRIP);
		for(j=0;j<N_lago-1;j++)
		{
			pto1.x=i/(float)(N_lago-1)*40.0-20.0;
			pto1.y=1.0+lago[i][j];
			pto1.z=(j/(float)(N_lago-1)*40.0-20.0)-4.0;

			pto2.x=i/(float)(N_lago-1)*40.0-20.0;
			pto2.y=1.0+lago[i][j+1];
			pto2.z=((j+1)/(float)(N_lago-1)*40.0-20.0)-4.0;

			pto3.x=(i+1)/(float)(N_lago-1)*40.0-20.0;
			pto3.y=1.0+lago[i+1][j+1];
			pto3.z=((j+1)/(float)(N_lago-1)*40.0-20.0)-4.0;

			pto4.x=(i+1)/(float)(N_lago-1)*40.0-20.0;
			pto4.y=1.0+lago[i+1][j];
			pto4.z=(j/(float)(N_lago-1)*40.0-20.0)-4.0;
/*		norm = cross(pto1,pto2,pto3,norm);

			x_norm = norm.x;
			y_norm = norm.y;
			z_norm = norm.z;
*/
			point3D cp1,cp2,cp3,cp4;

			cp1=pto1;
			cp2=pto2;
			cp3=pto3;
			cp4=pto4;

			glColor4f(0.0,0.8,0.8,0.9);
			normal(&pto1);
			glNormal3f(pto1.x,pto1.y,pto1.z);
//			calcolaColoreVerticeLago(lago[i][j]);
			glVertex3f(cp1.x,cp1.y,cp1.z);

			normal(&pto4);
			glNormal3f(pto4.x,pto4.y,pto4.z);
//			calcolaColoreVerticeLago(lago[i+1][j]);
			glVertex3f(cp4.x,cp4.y,cp4.z);
			
			normal(&pto2);
			glNormal3f(pto2.x,pto2.y,pto2.z);
//			calcolaColoreVerticeLago(lago[i][j+1]);
			glVertex3f(cp2.x,cp2.y,cp2.z);

			normal(&pto3);
			glNormal3f(pto3.x,pto3.y,pto3.z);
//			calcolaColoreVerticeLago(lago[i+1][j+1]);
			glVertex3f(cp3.x,cp3.y,cp3.z);
		
		}
		glEnd();
	}

	glDepthMask(GL_TRUE);
	glPopAttrib();
	glFlush();
	glutSwapBuffers();
}

void top_menu(int id)
{
	if(id==1)
		exit(0);
}
void sotto_menu(int id)
{
	if(id==1)
	{
		fillMode = 1; 
		glutPostRedisplay();
	}
	if(id==2)
	{
		fillMode = 0;
		glutPostRedisplay();
	}
}

void menu_luce(int id)
{
	switch(id)
	{
	case 1:
		light_position[0]+=5.0;
		break;
	case 2:
		light_position[0]-=5.0;
		break;
	case 3:
		light_position[1]+=5.0;
		break;
	case 4:
		light_position[1]-=5.0;
		break;
	case 5:
		light_position[2]+=5.0;
		break;
	case 6:
		light_position[2]-=5.0;
		break;
	}
	myInit();
	glutPostRedisplay();
	
}

void menu_camera(int id)
{
	switch(id)
	{
	case 1: viewer.x+=20.0;
			break;
	case 2: viewer.x-=20.0;
			break;
	case 3: viewer.y+=20.0;
			break;
	case 4: viewer.y-=20.0;
			break;
	case 5: viewer.z-=20.0;
			break;
	case 6: viewer.z+=20.0;
			break;
	}
	glutPostRedisplay();
}
void myReshape(int w,int h)
{
	glViewport(0,0,w,h);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(40,1,0.1,2000.0);
	glMatrixMode(GL_MODELVIEW);
	glutPostRedisplay();
}

int main(int argc, char** argv)
{
//	viewer.x=22;
//	viewer.y=22;
//	viewer.z=22;

	viewer.x=2;
	viewer.y=14;
	viewer.z=32;

	int sub_menu,sub_menu_luce,sub_menu_camera;

	glutInit(&argc,argv);
	glutInitWindowSize(500,500);
	glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE|GLUT_DEPTH);
	glutCreateWindow("Paesaggio 3D");
	glutKeyboardFunc(keys);
	myInit();
	glutReshapeFunc(myReshape);
	glutDisplayFunc(display);

	//creazione del menu
	sub_menu=glutCreateMenu(sotto_menu);
	glutAddMenuEntry("Render",1);
	glutAddMenuEntry("Wireframe",2);
	sub_menu_luce=glutCreateMenu(menu_luce);
	glutAddMenuEntry("Move right",1);
	glutAddMenuEntry("Move left",2);
	glutAddMenuEntry("Move top",3);
	glutAddMenuEntry("Move bottom",4);
	glutAddMenuEntry("Move ahead",5);
	glutAddMenuEntry("Move back",6);

	sub_menu_camera=glutCreateMenu(menu_camera);
	glutAddMenuEntry("Move right",1);
	glutAddMenuEntry("Move left",2);
	glutAddMenuEntry("Move top",3);
	glutAddMenuEntry("Move bottom",4);
	glutAddMenuEntry("Move ahead",5);
	glutAddMenuEntry("Move back",6);



	glutCreateMenu(top_menu);
	glutAddSubMenu("Show",sub_menu);
	glutAddSubMenu("Light position",sub_menu_luce);
	glutAddSubMenu("Camera position",sub_menu_camera);
	glutAddMenuEntry("Exit",1);
	glutAttachMenu(GLUT_RIGHT_BUTTON);



	glutMainLoop();
	return 0;
}