/* fractalLandscape.cpp 
// Program to draw a Brownian Fractal landscape
/* Programmed by Olac Fuentes
   Last modified October 28, 2009
   CS3370

*/

#include "stdafx.h"
#include <math.h>
#include <iostream>
#include "glut.h" 
#include <time.h>

using namespace std;

// Define a constant for the value of PI, from [2]
#define GL_PI 3.1415926535f
// Rotation amounts, from [2]
static GLfloat xRot =25.0;
static GLfloat yRot =-205.0;

GLfloat nRange = 100.0f;
// display window size
int winWidth=600;
int winHeight=600;
float water_level =0;
int randSeed;
float h=3;
float colorLimit[] = {1.,.7,.4,0};
float frx=winWidth/(2*nRange);
float fry=winHeight/(2*nRange);

// converts from degrees to radians
#define d2r(t) (3.1415926535*t/180)

struct wcPt2D { // adapted from [1]
	GLfloat x, y;
};
struct wcPt3D { // adapted from [1]
         GLfloat x, y, z;
};
// vertices counter
int vx_c=0;
// Modes
int op_mode=1; // 0: Points, 1: Polygons
int fill_poly=1;  // 0: wire, 1: filled
float axis_size=70.0;
int axis_on=0;
int smooth_color_on=0;

/**************************************/
// Keyboard Functions
void operations(GLubyte sizeFactor, GLint xMouse, GLint yMouse)
{
	switch (sizeFactor)
    {
		case ('q' | 'Q') :
            exit(0);
			break;
		case ('/') :
            h -= .1;
			break;
		case ('*') :
            h += .1;
			break;
		case ('+') :
			water_level+=.1;
			break;
		case ('-') :
			water_level-=.1;
			break;
		case ('w' | 'W'):
			colorLimit[1] -=.02;
			colorLimit[2] -=.02;
			break;
		case ('s'| 'S'):
			colorLimit[1] +=.02;
			colorLimit[2] +=.02;
			break;
		default:
            break;
      }
	glutPostRedisplay();
}

void getRGBColor(float intensity, float colorVect[]){
	// Compute altitude-derived colors
	float colorRef[4][3]={{1,1,1},{.5,.4,0},{.1,.3,.1},{0,0.1,0}};
	float frac;
	int i, index;
	intensity += 0.12*(1.*rand()/RAND_MAX-.5);

	if (intensity>1.)
		intensity=1.;
	if (intensity<0.)
		intensity=0.;
	for(i=0;i<3;i++)
		if (intensity <= colorLimit[i])
			index =i;
	frac = (intensity - colorLimit[index+1])/(colorLimit[index]-colorLimit[index+1]);
	for (i=0;i<3;i++){
		colorVect[i] = colorRef[index][i]*frac + colorRef[index+1][i]*(1.-frac);
	}
}

void brownianFractal(float h){
	
	int rows =200;
	int cols =200;
	wcPt3D v[200][200];
	int i,j;
	float intensity;
	float minXZ = -150;
	float maxXZ = 150;
	float colorVect[3];
	float maxY= 0;
	float minY= 0;
	float range = maxXZ-minXZ;
		
	//Build Grid
	for(i=0;i<rows;i++)
		for(j=0;j<cols;j++){
			v[i][j].x = minXZ+range*i/rows;
			v[i][j].y = 0;
			v[i][j].z = minXZ+range*j/rows;
		}

	// Compute y values using brownian fractal algorithm
	for(i=1;i<rows;i++)
		for(j=1;j<cols;j++){
			v[i][j].y = (v[i-1][j].y+v[i][j-1].y)/2 + h*(1.0*rand()/RAND_MAX-.5);
			if(v[i][j].y>maxY)
				maxY=v[i][j].y;
			else
				if(v[i][j].y<minY)
					minY=v[i][j].y;
		}	
	float rangeY = maxY-minY;
	
	// Smooth sea bottom
	for(i=0;i<rows;i++)
		for(j=0;j<cols;j++){
			if(v[i][j].y<water_level)
				v[i][j].y=water_level-.2;
		}

	// Draw grid polygons
	for(i=0;i<rows-1;i++)
		for(j=0;j<cols-1;j++){
		
			glBegin(GL_POLYGON);
			intensity = (v[i][j].y - minY)/rangeY;
			getRGBColor(intensity,colorVect);
			glColor3f (colorVect[0], colorVect[1], colorVect[2]); 
			glVertex3f(v[i][j].x, v[i][j].y, v[i][j].z);

			intensity = (v[i][j+1].y - minY)/rangeY;
			getRGBColor(intensity,colorVect);
			glColor3f (colorVect[0], colorVect[1], colorVect[2]); 
			glVertex3f(v[i][j+1].x, v[i][j+1].y, v[i][j+1].z);
			
			intensity = (v[i+1][j].y - minY)/rangeY;
			getRGBColor(intensity,colorVect);
			glColor3f (colorVect[0], colorVect[1], colorVect[2]); 		
			glVertex3f(v[i+1][j].x, v[i+1][j].y, v[i+1][j].z);
			glEnd();

			glBegin(GL_POLYGON);
			intensity = (v[i+1][j].y - minY)/rangeY;
			getRGBColor(intensity,colorVect);
			glColor3f (colorVect[0], colorVect[1], colorVect[2]); 	
			glVertex3f(v[i+1][j].x, v[i+1][j].y, v[i+1][j].z);

			intensity = (v[i+1][j+1].y - minY)/rangeY;
			getRGBColor(intensity,colorVect);
			glColor3f (colorVect[0], colorVect[1], colorVect[2]); 	
			glVertex3f(v[i+1][j+1].x, v[i+1][j+1].y, v[i+1][j+1].z);

			intensity = (v[i][j+1].y - minY)/rangeY;
			getRGBColor(intensity,colorVect);
			glColor3f (colorVect[0], colorVect[1], colorVect[2]); 	
			glVertex3f(v[i][j+1].x, v[i][j+1].y, v[i][j+1].z);
			glEnd();
		}

	// Draw water
	glBegin(GL_POLYGON);
	glColor3f (.1,.2,.4 );
	glVertex3f(v[0][0].x, water_level, v[0][0].z);
	glVertex3f(v[0][cols-1].x, water_level, v[0][cols-1].z);
	glVertex3f(v[rows-1][cols-1].x, water_level, v[rows-1][cols-1].z);
	glVertex3f(v[cols-1][0].x, water_level, v[cols-1][0].z);
	glEnd();

}

void fs(int seed, float h){
	srand(seed);
	brownianFractal(h);
}

/**********************************************************************/

// Called to draw scene, adapted from [2]
void RenderScene(void)
	{
	// Storeage for coordinates and angles
	// Clear the window with current clearing color
	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

	// Save matrix state and do the rotation
	glPushMatrix();
	glRotatef(xRot, 1.0f, 0.0f, 0.0f);
	glRotatef(yRot, 0.0f, 1.0f, 0.0f);
	
	GLfloat step = GL_PI/20.;
	GLfloat r=50.0;

	fs(randSeed,h);
	// Restore transformations
	glPopMatrix();
	// Flush drawing commands
	glutSwapBuffers();
	}

// This function does any needed initialization on the rendering
// context. from [2]
void SetupRC()
	{
	// Black background
	glClearColor(0.0f, 0.0f, 0.0f, 1.0f );
	// Set drawing color to green
	glColor3f(0.0f, 1.0f, 0.0f);
	glEnable(GL_DEPTH_TEST);
	glPolygonMode(GL_BACK,GL_FILL);
	glPolygonMode(GL_FRONT,GL_FILL);
	}

// adapted from [2]
void SpecialKeys(int key, int x, int y)
	{
	if(key == GLUT_KEY_UP)
		xRot-= 5.0f;
	if(key == GLUT_KEY_DOWN)
		xRot += 5.0f;
	if(key == GLUT_KEY_LEFT)
		yRot -= 5.0f;
	if(key == GLUT_KEY_RIGHT)
		yRot += 5.0f;
	glutPostRedisplay();
	}

// adapted from [2]
void ChangeSize(int w, int h)
	{
	// Prevent a divide by zero
	if(h == 0)
		h = 1;
	// Set Viewport to window dimensions
    glViewport(0, 0, w, h);
	// Reset projection matrix stack
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	// Establish clipping volume (left, right, bottom, top, near, far)
    if (w <= h) 
		glOrtho (-nRange, nRange, -nRange*h/w, nRange*h/w, -2*nRange, 2*nRange);
    else 
		glOrtho (-nRange*w/h, nRange*w/h, -nRange, nRange, -2*nRange, 2*nRange);

	// Reset Model view matrix stack
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	}

void display_commands()
{
	cout << "Use the direction keys to rotate the sphere\n";
	cout << "Keyboard Function:\n";
	cout << " +: Increase water level\n";
	cout << " -: Decrease water level\n";
	cout << " *: Increase surface roughness \n";
	cout << " /: Decrease surface roughness \n";
	cout << " s: Increase temperature \n";
	cout << " w: Decrease temperature \n";
	cout << " Q: quit the program\n";
	cout << "\n";
}

// adapted from [2]
int main(int argc, char* argv[])
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
	glutInitWindowPosition (800, 200);
	glutInitWindowSize(winWidth, winHeight);
	
	display_commands();
	
	glutCreateWindow("Brownian Fractal");
	glutReshapeFunc(ChangeSize);
	
	glutKeyboardFunc (operations);
	glutSpecialFunc(SpecialKeys);
	
	glutDisplayFunc(RenderScene);
	
	SetupRC();
	
	srand(time(NULL));
	randSeed = rand();

	glutMainLoop();

	return 0;
}