#include <windows.h>		// Header File For Windows
#include <stdlib.h>
#include <time.h>
#include <math.h>			// Math Library Header File
#include <stdio.h>			// Header File For Standard Input/Output
#include <GL\glut.h>		// Header File For The Glut Library

#define NUM_PARTICLES 20000
#define GRAVITY 0.00005f // (Gravity)
#define FRICTION 0.035f//Air resistance
#define SPRING_CONSTANT 0.01f

// Particle structure
typedef struct
 {
  float xPos,yPos,zPos;
  float xVec,yVec,zVec;
  bool dead;
 }Particle;

bool	keys[256];			// Array Used For The Keyboard Routine
Particle Pars[NUM_PARTICLES];
const float piover180 = 0.0174532925f;
float heading;
float xpos;
float ypos=0.0f;
float zpos;
float xstart=.5;
float ystart=0.0;
float zstart=1.0;
float SPRING_SIZE=0.13;
bool teapottoggle=true;
GLUquadricObj *quadratic;	// Storage For Our Quadratic Objects ( NEW )

GLfloat	yangle;				// Y Rotation
GLfloat lookupdown = 0.0f;

GLfloat pointamb[] = {0.0,0.0,1.0,1.0};
GLfloat pointdiff[] = {0.0,0.0,0.8,1.0};
GLfloat pointspec[] = {0.4,0.4,1.0,1.0};

GLfloat slinkyamb[] = {1.0,0.0,0.0,1.0};
GLfloat slinkydiff[] = {0.8,0.0,0.0,1.0};
GLfloat slinkyspec[] = {1.0,0.5,0.5,1.0};


Particle checkbounds(Particle p)
{
//Check walls, bounce off of them
if(2<p.xPos)
	p.xPos=1;
if(2<p.zPos)
	p.zPos=1;
if(-2>p.xPos)
	p.xPos=0;
if(-2>p.zPos)
	p.zPos=0;


if(0>p.xPos)
{
	p.xPos=p.xPos-2*p.xVec;
	p.xVec= -1*p.xVec;		
}

if(p.xPos>1)
	{
		p.xPos=p.xPos-2*p.xVec;
		p.xVec= -1*p.xVec;
	}

if((0>p.zPos))
	{	
		p.zPos=p.zPos-2*p.zVec;
		p.zVec= -1*p.zVec;		
	}

if(p.zPos>1)
	{	
		p.zPos=p.zPos-2*p.zVec;
		p.zVec= -1*p.zVec;		
	}
	
if(p.yPos>2)
	{			
		p.yVec=0;
	}
return p;
}


/*Shoots each particle with a random 
velocity from the nozzle's postion whenever it dies
*/
Particle Shoot(Particle p)
{
	p.dead=0;	
	p.yVec =(float) ((rand() / (RAND_MAX + 1.0)));
	while(p.yVec<((float) ((RAND_MAX + 1.0)/2)/(RAND_MAX + 1.0)))
		p.yVec =(float) ((rand() / (RAND_MAX + 1.0)));
	p.yVec = p.yVec/25;
	p.zVec = ((float) (rand() / (RAND_MAX + 1.0)));
	p.zVec /=10;
	p.xVec = (float) (rand() / (RAND_MAX + 1.0));
	p.xVec /=50;	
	if(rand() / (RAND_MAX + 1.0)<.5)
		p.xVec*=-1;	
	checkbounds(p);
	p.xPos=xstart+p.xVec;
	p.yPos=ystart+p.yVec;
	p.zPos=zstart+p.zVec;
return p;
}

//Block water from falling through rungs from above.  Not below, though
Particle checkRungs(Particle p)
{
if(p.yPos>1.0)//middle rung
	{
	if(p.xPos>.4 && p.xPos<.6)
		if(p.zPos<.25)
		if((p.yPos+(p.yVec-GRAVITY*10))<1.0)
			{
			p.yPos=1.01;
			p.yVec=0.0;
			p.xVec=.95*p.xVec;
			//p.zVec*=.99*p.zVec;
			}
	}


else if(p.yPos>.75)//middle rung
	{
	if(p.xPos>.3 && p.xPos<.7)
		if(p.zPos<.35)
		if(p.yPos+p.yVec-GRAVITY*10<.75)
			{
			p.yPos=.759;
			p.yVec=0;
			p.xVec=.95*p.xVec;
			}
	}
else if(p.yPos>.5)//bottom rung
	{
	if(p.xPos>.2 && p.xPos<.8)
		{
		if(p.zPos<.5)
			{		
			if(p.yPos+p.yVec-GRAVITY*10<.5)
				{
				p.yPos=.509;
				p.yVec=0;
				p.xVec=.95*p.xVec;
				}
			}
		}
	}

else if(p.yPos>0.0)//floor
	{
	if(p.xPos>0.0 && p.xPos<1.0)
		{
		if(p.zPos<0.5)
			{		
			if(p.yPos+p.yVec-GRAVITY*10<0.0)
				{
				p.yPos=.001;
				p.yVec=0;
				}
			}
		}
	}


return p;
}


void fountain(void)//takes care of physics for all active particles
{	
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, pointamb);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, pointdiff);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, pointspec);
	
for(int i=0; i<NUM_PARTICLES; i++)
	{		
	if(Pars[i].yPos<0)//kill particle, reshoot it if it falls below bottom
		Pars[i].dead=1;
	if(Pars[i].dead)
		Pars[i]=Shoot(Pars[i]);
	Pars[i]=checkRungs(Pars[i]);
	Pars[i]=checkbounds(Pars[i]);
	Pars[i].yVec-=GRAVITY*10;
	Pars[i].yPos=Pars[i].yPos+(Pars[i].yVec);
	if(Pars[i].xVec>0)//slows down particles like air resistance
		Pars[i].xVec-=FRICTION;
	else
		Pars[i].xVec+=FRICTION;
	Pars[i].xPos=Pars[i].xPos+Pars[i].xVec;	
	if(Pars[i].zVec>0)
		Pars[i].zVec-=FRICTION;
	else
		Pars[i].zVec+=FRICTION;
	Pars[i].zPos=Pars[i].zPos+Pars[i].zVec;
	}
glBegin(GL_POINTS);
for(int i=0; i<NUM_PARTICLES; i++)
	{		
	glVertex3f(Pars[i].xPos,Pars[i].yPos,Pars[i].zPos);
	}
glEnd();
return;
}


int InitGL(GLvoid)										// All Setup For OpenGL Goes Here
{
	GLfloat white[] = {1.0,1.0,1.0,1.0};
	GLfloat lpos[] = {0.0,0.5,0.0,0.0};

	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);

	glLightfv(GL_LIGHT0, GL_DIFFUSE, white);
	glLightfv(GL_LIGHT0, GL_SPECULAR, white);
	glLightfv(GL_LIGHT0, GL_POSITION, lpos);

	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);				// This Will Clear The Background Color To Black
	glClearDepth(1.0);									// Enables Clearing Of The Depth Buffer
	glDepthFunc(GL_LESS);								// The Type Of Depth Test To Do
	glEnable(GL_DEPTH_TEST);							// Enables Depth Testing
	glShadeModel(GL_SMOOTH);							// Enables Smooth Color Shading
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);	// Really Nice Perspective Calculations

	for(int i=0; i<NUM_PARTICLES; i++)					//initialize the particles
		Pars[i]=Shoot(Pars[i]);
	fountain();

    quadratic=gluNewQuadric();							// Create A Pointer To The Quadric Object (Return 0 If No Memory) (NEW)
	gluQuadricNormals(quadratic, GLU_SMOOTH);			// Create Smooth Normals (NEW)

	return TRUE;										// Initialization Went OK
}

//camera code
void dispView(void)
{
	GLfloat xtrans = -xpos;
	GLfloat ztrans = -zpos;
	GLfloat ytrans = ypos-0.25f;
	GLfloat sceneroty = 360.0f - yangle;

	GLfloat teaamb[] = {0.4,0.4,0.4,1.0};
	GLfloat teadiff[] = {0.0,0.0,0.0,1.0};	
	glRotatef(lookupdown,1.0f,0,0);	
	glRotatef(sceneroty,0,1.0f,0);	
	glTranslatef(xtrans, ytrans, ztrans);
	glTranslatef (-.5, .2, -1.0);      /* modeling transformation */ 
return;
}

//Display the fountain environment
void dispground()
{
	glPushMatrix();
	GLfloat stallamb[] = {0.3,0.3,0.3,1.0};
	GLfloat stalldiff[] = {0.8,0.8,0.8,1.0};
	GLfloat stallspec[] = {0.5,0.5,0.5,1.0};

	GLfloat rampamb[] = {0.4,0.4,0.4,1.0};
	GLfloat rampdiff[] = {0.5,0.5,0.5,1.0};
	GLfloat rampspec[] = {0.5,0.5,0.5,1.0};
	
	
	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, stallamb);
	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, stalldiff);
	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, stallspec);
	glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 10.0);

	glBegin(GL_QUADS);		

		glVertex3f(0.0,0.0,0.0);//back wall
		glVertex3f(1.0,0.0,0.0);		
		glVertex3f(1.0,2,0.0);
		glVertex3f(0.0,2,0.0);

		glVertex3f(1.0,0.0,0.0);//side walls
		glVertex3f(1.0,0.0,1.0);		
		glVertex3f(1.0,0.2,1.0);
		glVertex3f(1.0,0.2,0.0);

		glVertex3f(0.0,0.0,0.0);
		glVertex3f(0.0,0.0,1.0);		
		glVertex3f(0.0,0.2,1.0);
		glVertex3f(0.0,0.2,0.0);
		
		glVertex3f(0.0,0.0,0.0);//floor
		glVertex3f(1.0,0.0,0.0);
		glVertex3f(1.0,0.0,0.5);
		glVertex3f(0.0,0.0,0.5);
	glEnd();

	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, rampamb);
	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, rampdiff);
	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, rampspec);
	
	glBegin(GL_QUADS);
		glVertex3f(0.0, 0.2, 0.0);//baseboards
		glVertex3f(0.0, 0.2, 1.0);
		glVertex3f(0.0, 2.0, 1.0);
		glVertex3f(0.0, 2.0, 0.0);

		glVertex3f(1.0,0.2,0.0);
		glVertex3f(1.0,0.2,1.0);		
		glVertex3f(1.0,2.0,1.0);
		glVertex3f(1.0,2.0,0.0);



		glVertex3f(0.4,1.0,0.0);//stairs
		glVertex3f(0.6,1.0,0.0);		
		glVertex3f(0.6,1.0,0.25);
		glVertex3f(0.4,1.0,0.25);

		glVertex3f(0.3,0.75,0.0);//stairs
		glVertex3f(0.7,0.75,0.0);		
		glVertex3f(0.7,0.75,0.35);
		glVertex3f(0.3,0.75,0.35);
		
		glVertex3f(0.2,0.5,0.0);//stairs
		glVertex3f(0.8,0.5,0.0);		
		glVertex3f(0.8,0.5,0.5);
		glVertex3f(0.2,0.5,0.5);	
	glEnd();
	

	
	glTranslatef(xstart, ystart, zstart);
	glScalef(.01,.01,.01);
	//draw a nozzle
	glRotatef(90, 1.0, 0.0, 0.0);
	gluCylinder(quadratic,1.0f,2.0f,17.0f,32,32);	// A Cylinder With A Radius Of 0.5 And A Height Of 2
	glutSolidTorus(1.0, 1.1, 32, 32);
	
	glPopMatrix();
	return;
}

/*this is my spring code.  
Connects particle 0 and 1 that have teapots then drawn around them.*/
void Slinky(void)
{
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, slinkyamb);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, slinkydiff);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, slinkyspec);

glTranslatef(Pars[0].xPos, Pars[0].yPos, Pars[0].zPos);
if(teapottoggle)
	glutSolidTeapot(.04);
glTranslatef(-Pars[0].xPos, -Pars[0].yPos, -Pars[0].zPos);

glTranslatef(Pars[1].xPos, Pars[1].yPos, Pars[1].zPos);
if(teapottoggle)
	glutSolidTeapot(.04);
glTranslatef(-Pars[1].xPos, -Pars[1].yPos, -Pars[1].zPos);

if(teapottoggle)
{
glBegin(GL_LINES);
	glVertex3f(Pars[1].xPos,Pars[1].yPos,Pars[1].zPos);
	glVertex3f(Pars[0].xPos,Pars[0].yPos,Pars[0].zPos);
glEnd();
}

float xdiff=Pars[1].xPos-Pars[0].xPos;
float distance=xdiff*xdiff;
float ydiff=Pars[1].yPos-Pars[0].yPos;
distance+=ydiff*ydiff;
float zdiff=Pars[1].zPos-Pars[0].zPos;
distance+=zdiff*zdiff;
distance=sqrt(distance);
float deltaD=distance-SPRING_SIZE;
float force=deltaD*SPRING_CONSTANT;

float theta=acos(ydiff/distance);//use trigonometrical magics to calculate force components of the spring
float phi=acos(xdiff/(distance*sin(theta)));

float xforce=force*sin(theta)*cos(phi);
Pars[0].xVec+=xforce;
Pars[1].xVec-=xforce;

float yforce=force*cos(theta);
Pars[0].yVec+=yforce;
Pars[1].yVec-=yforce;

float zforce=force*sin(theta)*sin(phi);
Pars[0].zVec+=zforce;
Pars[1].zVec-=zforce;


return;
}

void display(void)									// Here's Where We Do All The Drawing
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	// Clear The Screen And The Depth Buffer
	glColor3f (1.0, 1.0, 1.0);

	glLoadIdentity();									// Reset The View
	dispView();
	
	dispground();

	fountain();
	Slinky();

	glutSwapBuffers();
	glFlush ();

	glutPostRedisplay();

	return;
}



void reshape (int w, int h)
{
	glViewport (0, 0, (GLsizei) w, (GLsizei) h); 
	glMatrixMode (GL_PROJECTION);
	glLoadIdentity ();
	gluPerspective(90.0,1.0,0.01,10.0);
	glMatrixMode (GL_MODELVIEW);
}

void keyboard(unsigned char key, int x, int y)
{
   switch (key) {
		case 27:
			exit(0);
			gluDeleteQuadric(quadratic);				// Delete Quadratic - Free Resources
			break;
		case 'q':
			lookupdown +=1;
			break;
		case 'z':
			lookupdown -=1;
			break;
		case 'e':
			ypos -=.01;
			break;
		case 'c':
			ypos +=.01;
			break;			
		case 'd':
			yangle -=3;
			break;
		case 'a':
			yangle +=3;
			break;			
		case 'i':
			if(ystart+.01<2)
			ystart +=.01;
			break;
		case 'k':
			if(ystart-.01>0)
				ystart -=.01;
			break;
		case 'u':
			if(zstart-.01>0)
			zstart -=.01;
			break;
		case 'o':
			if(zstart+.01<1)
				zstart +=.01;
			break;
		case 'j':
			if(xstart-.01>0)
				xstart -=.01;
			break;
		case 'l':
			if(xstart+.01<1)
				xstart +=.01;
			break;

		case 'w':
		xpos -= (float)sin(yangle*piover180) * 0.05f;
		zpos -= (float)cos(yangle*piover180) * 0.05f;
		break;

		case 's':
		xpos += (float)sin(yangle*piover180) * 0.05f;
		zpos += (float)cos(yangle*piover180) * 0.05f;					
		break;
		
		case 't':
		teapottoggle=!teapottoggle;
		break;
		
		case '1':
			pointamb[0]=0.0;
			pointamb[1]=0.0;
			pointamb[2]=1.0;
			pointamb[3]=1.0;
			break;
		case '2':
			pointamb[0]=1.0;
			pointamb[1]=1.0;
			pointamb[2]=0.0;
			pointamb[3]=1.0;
			break;
		case '3':
			pointamb[0]=1.0;
			pointamb[1]=0.0;
			pointamb[2]=0.0;
			pointamb[3]=1.0;
			break;
		case '4':
			pointamb[0]=1.0;
			pointamb[1]=1.0;
			pointamb[2]=1.0;
			pointamb[3]=1.0;
			break;
		case '5':
			pointamb[0]=0.0;
			pointamb[1]=1.0;
			pointamb[2]=0.0;
			pointamb[3]=1.0;
			break;
		case '6':
			pointamb[0]=0.2;
			pointamb[1]=0.2;
			pointamb[2]=0.2;
			pointamb[3]=1.0;
			break;
		case '-':
			if(SPRING_SIZE>.01)
				SPRING_SIZE-=0.01;
			break;
		case '=':
			SPRING_SIZE+=0.01;
			break;
		case '.':
			Pars[0].dead=1;
			Pars[1].dead=1;
			break;
		}
}

void keyboard2(int key2, int x, int y)
{
	switch (key2) {
	case GLUT_KEY_RIGHT:
		yangle -=3;
		break;
	case GLUT_KEY_LEFT:
		yangle +=3;
		break;
	case GLUT_KEY_DOWN:
		xpos += (float)sin(yangle*piover180) * 0.05f;
		zpos += (float)cos(yangle*piover180) * 0.05f;					
		break;
	case GLUT_KEY_UP:
		xpos -= (float)sin(yangle*piover180) * 0.05f;
		zpos -= (float)cos(yangle*piover180) * 0.05f;
		break;
	}
}


int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize (500, 500); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow (argv[0]);
   InitGL();
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape);
   glutKeyboardFunc(keyboard);
   glutSpecialFunc(keyboard2);
   glutMainLoop();
   return 0;
}