#include "TextureBuilder.h"
#include "Model_3DS.h"
#include "GLTexture.h"
#include <math.h>
#include <glut.h>
#include <iostream>
#include <string>
#include <iomanip>


#define DEG2RAD(a) (a * 0.0174532925)
#define GLUT_KEY_ESCAPE 27
class Vector3f {
public:
	float x, y, z;

	Vector3f(float _x = 0.0f, float _y = 0.0f, float _z = 0.0f) {
		x = _x;
		y = _y;
		z = _z;
	}

	Vector3f operator+(Vector3f &v) {
		return Vector3f(x + v.x, y + v.y, z + v.z);
	}

	Vector3f operator-(Vector3f &v) {
		return Vector3f(x - v.x, y - v.y, z - v.z);
	}

	Vector3f operator*(float n) {
		return Vector3f(x * n, y * n, z * n);
	}

	Vector3f operator/(float n) {
		return Vector3f(x / n, y / n, z / n);
	}

	Vector3f unit() {
		return *this / sqrt(x * x + y * y + z * z);
	}

	Vector3f cross(Vector3f v) {
		return Vector3f(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
	}
};
void Axis(){

	glColor3f(1.0, 0.0, 0.0); // red x
	glBegin(GL_LINES);
	// x aix

	glVertex3f(-4.0, 0.0f, 0.0f);
	glVertex3f(4.0, 0.0f, 0.0f);

	// arrow
	glVertex3f(4.0, 0.0f, 0.0f);
	glVertex3f(3.0, 1.0f, 0.0f);

	glVertex3f(4.0, 0.0f, 0.0f);
	glVertex3f(3.0, -1.0f, 0.0f);
	glEnd();
	glFlush();



	// y
	glColor3f(0.0, 1.0, 0.0); // green y
	glBegin(GL_LINES);
	glVertex3f(0.0, -4.0f, 0.0f);
	glVertex3f(0.0, 4.0f, 0.0f);

	// arrow
	glVertex3f(0.0, 4.0f, 0.0f);
	glVertex3f(1.0, 3.0f, 0.0f);

	glVertex3f(0.0, 4.0f, 0.0f);
	glVertex3f(-1.0, 3.0f, 0.0f);
	glEnd();
	glFlush();

	// z
	glColor3f(0.0, 0.0, 1.0); // blue z
	glBegin(GL_LINES);
	glVertex3f(0.0, 0.0f, -4.0f);
	glVertex3f(0.0, 0.0f, 4.0f);

	// arrow
	glVertex3f(0.0, 0.0f, 4.0f);
	glVertex3f(0.0, 1.0f, 3.0f);

	glVertex3f(0.0, 0.0f, 4.0f);
	glVertex3f(0.0, -1.0f, 3.0f);
	glEnd();
	glFlush();
}
class Camera {
public:
	Vector3f eye, center, up;
	Camera(float eyeX = 1.2f, float eyeY = 10.1f, float eyeZ = 32.3f, float centerX = 1.22f, float centerY = 9.6f, float centerZ = 31.4f, float upX = 0.0f, float upY = 1.0f, float upZ = 0.0f) {
		eye = Vector3f(eyeX, eyeY, eyeZ);
		center = Vector3f(centerX, centerY, centerZ);
		up = Vector3f(upX, upY, upZ);
	}

	void moveX(float d) {
		Vector3f right = up.cross(center - eye).unit();
		eye = eye + right * d;
		center = center + right * d;
	}

	void moveY(float d) {
		eye = eye + up.unit() * d;
		center = center + up.unit() * d;
	}

	void moveZ(float d) {
		Vector3f view = (center - eye).unit();
		eye = eye + view * d;
		center = center + view * d;
	}
	void changePrespective(float x, float y, float z){
		float centerX = 0.0f;
		float centerY = 0.0f;
		float centerZ = 0.0f;
		float upX = 0.0f;
		float upY = 1.0f;
		float upZ = 0.0f;
		eye = Vector3f(x, y, z);
		center = Vector3f(centerX, centerY, centerZ);
		up = Vector3f(upX, upY, upZ);
	}

	void rotateX(float a) {
		Vector3f view = (center - eye).unit();
		Vector3f right = up.cross(view).unit();
		view = view * cos(DEG2RAD(a)) + up * sin(DEG2RAD(a));
		up = view.cross(right);
		center = eye + view;
	}

	void rotateY(float a) {
		Vector3f view = (center - eye).unit();
		Vector3f right = up.cross(view).unit();
		view = view * cos(DEG2RAD(a)) + right * sin(DEG2RAD(a));
		right = view.cross(up);
		center = eye + view;
	}

	void look(float frogx,float frogy,float frogz,int perspective,int xValue) {
		if (perspective == 3){
			center.z = frogz;
			center.y = frogy;
			center.x = frogx;
			eye.z = frogz + 15;
			eye.y = frogy + 15;
			eye.x = frogx;
		}
		else{
			eye.z = frogz-1;
			eye.y = frogy+2;
			eye.x = frogx;
			center.x = frogx + xValue;
			center.y = frogy+2;
			center.z = -200;
		}

		gluLookAt(
			eye.x, eye.y, eye.z,
			center.x, center.y, center.z,
			up.x, up.y, up.z
			);
	}
};

struct Obstacle { // TODO : Change static variables
	float x;
	float y=1.3;
	float z;
	bool drawable = false;
	int direction; //1 = left-> right / -1 = right ->left / 0 not initalized
	int timeToLive=100;
	int timeToStart;
	int timer = 0;
	int modelNumber = 0;
	float speed = 1;
};
int* bezier(float t, int* p0, int* p1, int* p2, int* p3);
void FrogKeyboard(unsigned char, int, int);
void print(int x, int y, int z, char *string);
void initalizeFrog();
void Anim();
void drawBush(double, double);
int WIDTH = 1800;
int HEIGHT = 800;

GLuint tex;
char title[] = "3D Model Loader Sample";

// 3D Projection Options
Model_3DS model_car;
Model_3DS model_truck;
Model_3DS model_police;
Model_3DS model_batcar;
Model_3DS model_tank;
Model_3DS model_gallardo;
Model_3DS model_ferrari;
Model_3DS model_bike;
Model_3DS model_Camaro;
Model_3DS model_trophy;
Model_3DS model_aston;
Model_3DS model_bushes;
Model_3DS model_tree2;
Model_3DS model_tree;


Model_3DS models[11]; //TODO: change LAter
GLuint fskin;
GLuint fneck;
GLuint feyes;
GLuint dskin;
GLuint feet;
GLuint flegs;
GLuint ground;
GLdouble fovy = 45.0;
GLdouble aspectRatio = (GLdouble)WIDTH / (GLdouble)HEIGHT;
GLdouble zNear = 0.001;
GLdouble zFar = 500;
Camera camera;
Obstacle allCars[5][50];
int level = 1;
float angle = 0.0f;
float angle1 = 0.0f;
float alpha = 0.0f;
float frogrotation = 180; //global variable for frog orientation
float legrotation = 0;	//global variable for leg movement
float armrotation = 0;	//global variable for arm movement
float  movement = 0;	//useless for now
float frogx;		//starting x
float frogy;		//starting y
float frogz;		//starting z
float lightx = 0.7;
float lighty = 0.7;
float lightz = 0.7;
int frogcoord[2];		//Used to gather coordinates from bezier to set x,y,z
int frogbezier1[2];		//used for bezier movement
int frogbezier2[2];		//used for bezier movement
int frogbezier3[2];		//used for bezier movement
int frogbezier4[2];		//used for bezier movement
float frogtimer = 0;		//used for leg and arm
bool enablefrog = true;		//flag to enable keg arm and bezier movement
bool flaglegA = true;		//flag to enable leg movement
bool frogflagjump = false;	//flag to check that we move in one direction
int finalZs[5];
bool developerMode = 0;
int globalTimer = 0;
int xValue = 0;
bool hit = false;
int totalScore=0;
int currentLevelScore=0;
int perspective = 3; // 1->first person view  3->3rd person
bool won = false;
void setupCamera() {
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(60, 1800 / 800, 0.001, 500);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	camera.look(frogx,frogy,frogz,perspective,xValue);
}

int cameraZoom = 0;


// Textures


//=======================================================================
// Lighting Configuration Function
//=======================================================================
void InitLightSource()
{
	// Enable Lighting for this OpenGL Program
	glEnable(GL_LIGHTING);

	// Enable Light Source number 0
	// OpengL has 8 light sources
	glEnable(GL_LIGHT0);

	// Define Light source 0 ambient light
	GLfloat ambient[] = { 0.1f, 0.1f, 0.1, 1.0f };
	glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);

	// Define Light source 0 diffuse light
	GLfloat diffuse[] = { 0.5f, 0.5f, 0.5f, 1.0f };
	glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);

	// Define Light source 0 Specular light
	GLfloat specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
	glLightfv(GL_LIGHT0, GL_SPECULAR, specular);

	// Finally, define light source 0 position in World Space
	GLfloat light_position[] = { 0.0f, 10.0f, 0.0f, 1.0f };
	glLightfv(GL_LIGHT0, GL_POSITION, light_position);
}

//=======================================================================
// Material Configuration Function
//======================================================================
void InitMaterial()
{
	// Enable Material Tracking
	glEnable(GL_COLOR_MATERIAL);

	// Sich will be assigneet Material Properties whd by glColor
	glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);

	// Set Material's Specular Color
	// Will be applied to all objects
	GLfloat specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
	glMaterialfv(GL_FRONT, GL_SPECULAR, specular);

	// Set Material's Shine value (0->128)
	GLfloat shininess[] = { 96.0f };
	glMaterialfv(GL_FRONT, GL_SHININESS, shininess);
}

//=======================================================================
// OpengGL Configuration Function
//=======================================================================
void myInit(void)
{
	glClearColor(0.0, 0.0, 0.0, 0.0);

	glMatrixMode(GL_PROJECTION);

	glLoadIdentity();



	glMatrixMode(GL_MODELVIEW);

	glLoadIdentity();

	InitMaterial();

	glEnable(GL_DEPTH_TEST);

	glEnable(GL_NORMALIZE);
}

//=======================================================================
// Render Ground Function
//=======================================================================
void renderGround()
{
	glDisable(GL_LIGHTING);	// Disable lighting

	glColor3f(0.6, 0.6, 0.6);	// Dim the ground texture a bit

	glEnable(GL_TEXTURE_2D);	// Enable 2D texturing

	/*glBindTexture(GL_TEXTURE_2D, ground);	// Bind the ground texture


	glPushMatrix();
	glBegin(GL_QUADS);
	glNormal3f(0, 1, 0);	// Set quad normal direction.
	glTexCoord2f(0, 0);		// Set tex coordinates ( Using (0,0) -> (5,5) with texture wrapping set to GL_REPEAT to simulate the ground repeated grass texture).
	glVertex3f(-20, 0, -20);
	glTexCoord2f(5, 0);
	glVertex3f(20, 0, -20);
	glTexCoord2f(5, 5);
	glVertex3f(20, 0, 20);
	glTexCoord2f(0, 5);
	glVertex3f(-20, 0, 20);
	glEnd();
	glPopMatrix();*/

	glEnable(GL_LIGHTING);	// Enable lighting again for other entites coming throung the pipeline.

	glColor3f(1, 1, 1);	// Set material back to white instead of grey used for the ground texture.
}

void renderWhiteStripes(float fromX, float toX, float Z, float StepBetweenStripes){

	glDisable(GL_LIGHTING);

	while (fromX + 3 < toX){
		glPushMatrix();
		glBegin(GL_QUADS);
		glColor3f(1, 1, 1);
		glNormal3f(0, -1, 0);
		glVertex3f(fromX, 1.5, Z - 0.4);
		glVertex3f(fromX, 1.5, Z + 0.4);
		glVertex3f(fromX + 3, 1.5, Z + 0.4);
		glVertex3f(fromX + 3, 1.5, Z - 0.4);
		fromX += StepBetweenStripes + 3;
		glPopMatrix();
	}

	glEnable(GL_LIGHTING);


}

bool checkOverlapping(float x, float y, float z){
	bool ox = false;
	bool oy = false;
	bool oz = false;
	if (frogx >= x - 2 && frogx <= x + 2)
		ox = true;

	if (frogz >= z - 1.5&&frogz <= z + 1.5)
		oy = true;


	if (frogy >= y - 2 && frogy <= y + 2)
		oz = true;


	return ox&&oy&&oz;
}
void collisionOccured(){
	PlaySound("jump36.wav", NULL, SND_ASYNC | SND_FILENAME);
	hit = true;
	lightx = 0;
	lighty = 0;
	lightz = 0;
	initalizeFrog();
}
void checkCollision(){
	for (int i = 0; i < (sizeof(allCars[level - 1]) / sizeof(*allCars[level - 1])); i++){
		Obstacle car  = allCars[level - 1][i];
		if (car.direction != 0){
			bool status = checkOverlapping(car.x, car.y, car.z);
			if (status)
				collisionOccured();
		}


	}
}

void finalWin(){
	won = true;
}
void checkWon(){
	if (frogz <= finalZs[level-1]){

		if (level == 3){
			finalWin();
			return;
		}
		level++;
		hit = true;
		totalScore += currentLevelScore;
		currentLevelScore = 0;

		initalizeFrog();

	}
}
void moveCarRight(int carPos){

	if (allCars[level-1][carPos].timeToStart <= globalTimer)
		allCars[level-1][carPos].drawable = true;

	if (allCars[level-1][carPos].drawable){
		allCars[level-1][carPos].timer++;
		allCars[level-1][carPos].x+=allCars[level-1][carPos].speed;

		if (allCars[level-1][carPos].x > 23)
			allCars[level-1][carPos].drawable = false;

		if (allCars[level-1][carPos].timer > allCars[level-1][carPos].timeToLive)
		{
			allCars[level-1][carPos].x = -20;
			allCars[level-1][carPos].drawable = true;
			allCars[level-1][carPos].timer = 0;
		}

	}
}
void moveCarLeft(int carPos){

	if (allCars[level-1][carPos].timeToStart <= globalTimer)
		allCars[level-1][carPos].drawable = true;

	if (allCars[level-1][carPos].drawable){
		allCars[level-1][carPos].timer++;
		allCars[level-1][carPos].x-=allCars[level-1][carPos].speed;

		if (allCars[level-1][carPos].x < -20)
			allCars[level-1][carPos].drawable = false;

		if (allCars[level-1][carPos].timer > allCars[level-1][carPos].timeToLive)
		{
			allCars[level-1][carPos].x = 20;
			allCars[level-1] [carPos].drawable = true;
			allCars[level-1][carPos].timer = 0;
		}
	}
}
void updateScore(){
	int numberOfCarsPassed=0;
	for (int i = 0; i < (sizeof(allCars[level - 1]) / sizeof(*allCars[level - 1])); i++){
		if (frogz < allCars[level - 1][i].z&&allCars[level-1][i].direction!=0){
			numberOfCarsPassed++;
		}
	}
	currentLevelScore = numberOfCarsPassed * 10;
}
void restoreLight(){
	if (lightx < 0.69){
		lightx += 0.1;
		lightz += 0.1;
		lighty += 0.1;
	}
}
void timeF(int val)
{

	globalTimer++;
	for (int i = 0; i < (sizeof(allCars[level-1]) / sizeof(*allCars[level-1])); i++){
		if (allCars[level-1][i].direction == 0) // If it is not initalized
			continue;
		if (allCars[level-1][i].direction == 1)
			moveCarRight(i);
			else
				moveCarLeft(i);
	}
	checkCollision();
	checkWon();
	restoreLight();
	updateScore();
	glutPostRedisplay();

	glutTimerFunc(100, timeF, 0);
}

void skyBox(){
	glPushMatrix();

	GLUquadricObj * qobj;
	qobj = gluNewQuadric();
	glTranslated(50, 0, 0);
	glRotated(90, 1, 0, 1);
	glBindTexture(GL_TEXTURE_2D, tex);
	gluQuadricTexture(qobj, true);
	gluQuadricNormals(qobj, GL_SMOOTH);
	gluSphere(qobj, 300, 300, 300);
	gluDeleteQuadric(qobj);


	glPopMatrix();

}

void level1(){
	//Our Fancy Level 1

	//glEnable(GL_TEXTURE_2D);
	//glBindTexture(GL_TEXTURE_2D, tex_ground.texture[0]);

	//First Green Region
	glPushMatrix();
	glBindTexture(GL_TEXTURE_2D, ground);
	glBegin(GL_QUADS);
	glColor3f(0, 1, 0);
	glNormal3f(0, 1, 0);
	glTexCoord2f(0, 0);
	glVertex3f(-20, 1, -65);
	glTexCoord2f(5, 0);
	glVertex3f(-20, 1, 25);
	glTexCoord2f(5, 5);
	glVertex3f(20, 1, 25);
	glTexCoord2f(0, 5);
	glVertex3f(20, 1, -65);
	glEnd();
	glPopMatrix();


	//First Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, 0);
	glVertex3f(-20, 5, -10);

	glVertex3f(-20, 1, -10);
	glVertex3f(-20, 1, 0);
	glEnd();
	glPopMatrix();

	//First Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, 0);
	glVertex3f(20, 5, -10);
	glVertex3f(20, 1, -10);
	glVertex3f(20, 1, 0);
	glEnd();
	glPopMatrix();

	//First Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, 0);
	glVertex3f(-20, 1.3, -10);
	glVertex3f(20, 1.3, -10);
	glVertex3f(20, 1.3, 0);
	glEnd();
	glPopMatrix();

	glPushMatrix();
	//First White Stripes
	renderWhiteStripes(-20, 20, -5, 1);
	//Second White Stripes
	renderWhiteStripes(-20, 20, -37.5, 1);
	//Third White Stripes
	renderWhiteStripes(-20, 20, -27.5, 1);
	glPopMatrix();

	//Second Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, -20);
	glVertex3f(-20, 5, -45);
	glVertex3f(-20, 1, -45);
	glVertex3f(-20, 1, -20);
	glEnd();
	glPopMatrix();

	//Second Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, -20);
	glVertex3f(20, 5, -45);
	glVertex3f(20, 1, -45);
	glVertex3f(20, 1, -20);
	glEnd();
	glPopMatrix();

	//Second Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, -20);
	glVertex3f(-20, 1.3, -45);
	glVertex3f(20, 1.3, -45);
	glVertex3f(20, 1.3, -20);
	glEnd();
	glPopMatrix();

	glColor3f(1, 1, 1);

	drawBush(-5, 5);
	drawBush(10, -55);

	glPushMatrix();
	glTranslatef(18, 0, 5);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-18, 0, 5);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(18, 0, -15);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-18, 0, -15);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(18, 0, -55);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-18, 0, -55);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

}

void level2(){
	//Our Fancy Level 2


	//First Green Region
	glPushMatrix();
	glBindTexture(GL_TEXTURE_2D, ground);
	glBegin(GL_QUADS);
	glColor3f(0, 1, 0);
	glNormal3f(0, 1, 0);
	glTexCoord2f(0, 0);
	glVertex3f(-20, 1, -55);
	glTexCoord2f(5, 0);
	glVertex3f(-20, 1, 25);
	glTexCoord2f(5, 5);
	glVertex3f(20, 1, 25);
	glTexCoord2f(0, 5);
	glVertex3f(20, 1, -55);
	glEnd();
	glPopMatrix();



	//First Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, 10);
	glVertex3f(-20, 5, 5);
	glVertex3f(-20, 1, 5);
	glVertex3f(-20, 1, 10);
	glEnd();
	glPopMatrix();

	//First Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, 10);
	glVertex3f(20, 5, 5);
	glVertex3f(20, 1, 5);
	glVertex3f(20, 1, 10);
	glEnd();
	glPopMatrix();

	//First Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, 10);
	glVertex3f(-20, 1.3, 5);
	glVertex3f(20, 1.3, 5);
	glVertex3f(20, 1.3, 10);
	glEnd();
	glPopMatrix();

	//Second Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, 0);
	glVertex3f(-20, 5, -10);
	glVertex3f(-20, 1, -10);
	glVertex3f(-20, 1, 0);
	glEnd();
	glPopMatrix();

	//Second Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, 0);
	glVertex3f(20, 5, -10);
	glVertex3f(20, 1, -10);
	glVertex3f(20, 1, 0);
	glEnd();
	glPopMatrix();

	renderWhiteStripes(-20, 20, -5, 1);

	//Second Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, 0);
	glVertex3f(-20, 1.3, -10);
	glVertex3f(20, 1.3, -10);
	glVertex3f(20, 1.3, 0);
	glEnd();
	glPopMatrix();


	//Third Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, -20);
	glVertex3f(-20, 5, -40);
	glVertex3f(-20, 1, -40);
	glVertex3f(-20, 1, -20);
	glEnd();
	glPopMatrix();

	//Third Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, -20);
	glVertex3f(20, 5, -40);
	glVertex3f(20, 1, -40);
	glVertex3f(20, 1, -20);
	glEnd();
	glPopMatrix();

	renderWhiteStripes(-20, 20, -25, 1);
	renderWhiteStripes(-20, 20, -30, 1);
	renderWhiteStripes(-20, 20, -35, 1);

	//Third Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, -20);
	glVertex3f(-20, 1.3, -40);
	glVertex3f(20, 1.3, -40);
	glVertex3f(20, 1.3, -20);
	glEnd();
	glPopMatrix();

	glColor3f(1, 1, 1);

	drawBush(-15, 3);
	drawBush(5, 3);
	drawBush(-15, -12);
	drawBush(10, -18);
	drawBush(0, -49);

	glPushMatrix();
	glTranslatef(-14, 0, 15);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(10, 0, 10);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-7, 0, -15);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(18, 0, -47);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-18, 0, -47);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();



}

void level3(){
	//Our Fancy Level 3


	//First Green Region
	glPushMatrix();
	glBindTexture(GL_TEXTURE_2D, ground);
	glBegin(GL_QUADS);
	glColor3f(0, 1, 0);
	glNormal3f(0, 1, 0);
	glTexCoord2f(0, 0);
	glVertex3f(-20, 1, -75);
	glTexCoord2f(5, 0);
	glVertex3f(-20, 1, 25);
	glTexCoord2f(5, 5);
	glVertex3f(20, 1, 25);
	glTexCoord2f(0, 5);
	glVertex3f(20, 1, -75);
	glEnd();
	glPopMatrix();



	//First Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, 15);
	glVertex3f(-20, 5, 0);
	glVertex3f(-20, 1, 0);
	glVertex3f(-20, 1, 15);
	glEnd();
	glPopMatrix();

	//First Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, 15);
	glVertex3f(20, 5, 0);
	glVertex3f(20, 1, 0);
	glVertex3f(20, 1, 15);
	glEnd();
	glPopMatrix();

	renderWhiteStripes(-20, 20, 5, 1);
	renderWhiteStripes(-20, 20, 10, 1);

	//First Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, 15);
	glVertex3f(-20, 1.3, 0);
	glVertex3f(20, 1.3, 0);
	glVertex3f(20, 1.3, 15);
	glEnd();
	glPopMatrix();

	//Second Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, -5);
	glVertex3f(-20, 5, -15);
	glVertex3f(-20, 1, -15);
	glVertex3f(-20, 1, -5);
	glEnd();
	glPopMatrix();

	//Second Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, -5);
	glVertex3f(20, 5, -15);
	glVertex3f(20, 1, -15);
	glVertex3f(20, 1, -5);
	glEnd();
	glPopMatrix();

	renderWhiteStripes(-20, 20, -10, 1);

	//Second Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, -5);
	glVertex3f(-20, 1.3, -15);
	glVertex3f(20, 1.3, -15);
	glVertex3f(20, 1.3, -5);
	glEnd();
	glPopMatrix();

	//Third Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, -25);
	glVertex3f(-20, 5, -50);
	glVertex3f(-20, 1, -50);
	glVertex3f(-20, 1, -25);
	glEnd();
	glPopMatrix();

	//Third Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, -25);
	glVertex3f(20, 5, -50);
	glVertex3f(20, 1, -50);
	glVertex3f(20, 1, -25);
	glEnd();
	glPopMatrix();

	renderWhiteStripes(-20, 20, -30, 1);
	renderWhiteStripes(-20, 20, -35, 1);
	renderWhiteStripes(-20, 20, -40, 1);
	renderWhiteStripes(-20, 20, -45, 1);

	//Third Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, -25);
	glVertex3f(-20, 1.3, -50);
	glVertex3f(20, 1.3, -50);
	glVertex3f(20, 1.3, -25);
	glEnd();
	glPopMatrix();

	glColor3f(1, 1, 1);

	drawBush(-3, -3);
	drawBush(-7, -16);
	drawBush(9, -22);
	drawBush(-2, -55);

	glPushMatrix();
	glTranslatef(10, 0, 18);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-15, 0, -3);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(5, 0, -3);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-10, 0, -20);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(15, 0, -60);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-5, 0, -60);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();


}

void level4(){

	//Our Fancy Level 4


	//First Green Region
	glPushMatrix();
	glBindTexture(GL_TEXTURE_2D, ground);
	glBegin(GL_QUADS);
	glColor3f(0, 1, 0);
	glNormal3f(0, 1, 0);
	glTexCoord2f(0, 0);
	glVertex3f(-20, 1, -80);
	glTexCoord2f(5, 0);
	glVertex3f(-20, 1, 25);
	glTexCoord2f(5, 5);
	glVertex3f(20, 1, 25);
	glTexCoord2f(0, 5);
	glVertex3f(20, 1, -80);
	glEnd();
	glPopMatrix();



	//First Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, 10);
	glVertex3f(-20, 5, 0);
	glVertex3f(-20, 1, 0);
	glVertex3f(-20, 1, 10);
	glEnd();
	glPopMatrix();

	//First Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, 10);
	glVertex3f(20, 5, 0);
	glVertex3f(20, 1, 0);
	glVertex3f(20, 1, 10);
	glEnd();
	glPopMatrix();

	renderWhiteStripes(-20, 20, 5, 1);

	//First Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, 10);
	glVertex3f(-20, 1.3, 0);
	glVertex3f(20, 1.3, 0);
	glVertex3f(20, 1.3, 10);
	glEnd();
	glPopMatrix();

	//Second Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, -15);
	glVertex3f(-20, 5, -30);
	glVertex3f(-20, 1, -30);
	glVertex3f(-20, 1, -15);
	glEnd();
	glPopMatrix();

	//Second Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, -15);
	glVertex3f(20, 5, -30);
	glVertex3f(20, 1, -30);
	glVertex3f(20, 1, -15);
	glEnd();
	glPopMatrix();

	renderWhiteStripes(-20, 20, -20, 1);
	renderWhiteStripes(-20, 20, -25, 1);

	//Second Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, -15);
	glVertex3f(-20, 1.3, -30);
	glVertex3f(20, 1.3, -30);
	glVertex3f(20, 1.3, -15);
	glEnd();
	glPopMatrix();


	//Third Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, -40);
	glVertex3f(-20, 5, -55);
	glVertex3f(-20, 1, -55);
	glVertex3f(-20, 1, -40);
	glEnd();
	glPopMatrix();

	//Third Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, -40);
	glVertex3f(20, 5, -55);
	glVertex3f(20, 1, -55);
	glVertex3f(20, 1, -40);
	glEnd();
	glPopMatrix();

	renderWhiteStripes(-20, 20, -45, 1);
	renderWhiteStripes(-20, 20, -50, 1);

	//Third Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, -40);
	glVertex3f(-20, 1.3, -55);
	glVertex3f(20, 1.3, -55);
	glVertex3f(20, 1.3, -40);
	glEnd();
	glPopMatrix();


	//Fourth Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, -60);
	glVertex3f(-20, 5, -75);
	glVertex3f(-20, 1, -75);
	glVertex3f(-20, 1, -60);
	glEnd();
	glPopMatrix();

	//Fourth Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, -60);
	glVertex3f(20, 5, -75);
	glVertex3f(20, 1, -75);
	glVertex3f(20, 1, -60);
	glEnd();
	glPopMatrix();

	renderWhiteStripes(-20, 20, -65, 1);
	renderWhiteStripes(-20, 20, -70, 1);

	//Fourth Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, -60);
	glVertex3f(-20, 1.3, -75);
	glVertex3f(20, 1.3, -75);
	glVertex3f(20, 1.3, -60);
	glEnd();
	glPopMatrix();

	glColor3f(1, 1, 1);

	drawBush(-7, -3);
	drawBush(-18, -8);
	drawBush(17, -12);
	drawBush(4, -35);
	drawBush(2, -57);
	drawBush(-14, -77);
	drawBush(11, -77);

	//First 2 Tree's
	glPushMatrix();
	glTranslatef(-15, 0, 15);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(5, 0, 20);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();
	//Second Tree
	glPushMatrix();
	glTranslatef(5, 0, -3);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();
	//Third Tree
	glPushMatrix();
	glTranslatef(-5, 0, -12);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();
	//Fourth Tree
	glPushMatrix();
	glTranslatef(18, 0, -35);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();
	//Fifth Tree
	glPushMatrix();
	glTranslatef(-18, 0, -58);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	//Sixth Tree
	glPushMatrix();
	glTranslatef(-18, 0, -77);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	//Seventh Tree
	glPushMatrix();
	glTranslatef(-10, 0, -77);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	//Eigth Tree
	glPushMatrix();
	glTranslatef(7, 0, -77);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	//Ninth Tree
	glPushMatrix();
	glTranslatef(15, 0, -77);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

}

void level5(){

	//Our Fancy Level 5


	//First Green Region
	glPushMatrix();
	glBindTexture(GL_TEXTURE_2D, ground);
	glBegin(GL_QUADS);
	glColor3f(0, 1, 0);
	glNormal3f(0, 1, 0);
	glTexCoord2f(0, 0);
	glVertex3f(-20, 1, -180);
	glTexCoord2f(5, 0);
	glVertex3f(-20, 1, 25);
	glTexCoord2f(5, 5);
	glVertex3f(20, 1, 25);
	glTexCoord2f(0, 5);
	glVertex3f(20, 1, -180);
	glEnd();
	glPopMatrix();



	//First Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, 15);
	glVertex3f(-20, 5, 0);
	glVertex3f(-20, 1, 0);
	glVertex3f(-20, 1, 15);
	glEnd();
	glPopMatrix();

	//First Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, 15);
	glVertex3f(20, 5, 0);
	glVertex3f(20, 1, 0);
	glVertex3f(20, 1, 15);
	glEnd();
	glPopMatrix();

	renderWhiteStripes(-20, 20, 5, 1);
	renderWhiteStripes(-20, 20, 10, 1);

	//First Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, 15);
	glVertex3f(-20, 1.3, 0);
	glVertex3f(20, 1.3, 0);
	glVertex3f(20, 1.3, 15);
	glEnd();
	glPopMatrix();


	//Second Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, -5);
	glVertex3f(-20, 5, -20);
	glVertex3f(-20, 1, -20);
	glVertex3f(-20, 1, -5);
	glEnd();
	glPopMatrix();

	//Second Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, -5);
	glVertex3f(20, 5, -20);
	glVertex3f(20, 1, -20);
	glVertex3f(20, 1, -5);
	glEnd();
	glPopMatrix();

	renderWhiteStripes(-20, 20, -10, 1);
	renderWhiteStripes(-20, 20, -15, 1);

	//Second Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, -5);
	glVertex3f(-20, 1.3, -20);
	glVertex3f(20, 1.3, -20);
	glVertex3f(20, 1.3, -5);
	glEnd();
	glPopMatrix();

	//Third Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, -25);
	glVertex3f(-20, 5, -40);
	glVertex3f(-20, 1, -40);
	glVertex3f(-20, 1, -25);
	glEnd();
	glPopMatrix();

	//Third Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, -25);
	glVertex3f(20, 5, -40);
	glVertex3f(20, 1, -40);
	glVertex3f(20, 1, -25);
	glEnd();
	glPopMatrix();

	renderWhiteStripes(-20, 20, -30, 1);
	renderWhiteStripes(-20, 20, -35, 1);

	//Third Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, -25);
	glVertex3f(-20, 1.3, -40);
	glVertex3f(20, 1.3, -40);
	glVertex3f(20, 1.3, -25);
	glEnd();
	glPopMatrix();

	//Fourth Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, -45);
	glVertex3f(-20, 5, -50);
	glVertex3f(-20, 1, -50);
	glVertex3f(-20, 1, -45);
	glEnd();
	glPopMatrix();

	//Fourth Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, -45);
	glVertex3f(20, 5, -50);
	glVertex3f(20, 1, -50);
	glVertex3f(20, 1, -45);
	glEnd();
	glPopMatrix();

	//Fourth Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, -45);
	glVertex3f(-20, 1.3, -50);
	glVertex3f(20, 1.3, -50);
	glVertex3f(20, 1.3, -45);
	glEnd();
	glPopMatrix();

	//Fifth Left Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 5, -55);
	glVertex3f(-20, 5, -105);
	glVertex3f(-20, 1, -105);
	glVertex3f(-20, 1, -55);
	glEnd();
	glPopMatrix();

	//Fifth Right Portal
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 1);
	glNormal3f(0, 1, 0);
	glVertex3f(20, 5, -55);
	glVertex3f(20, 5, -105);
	glVertex3f(20, 1, -105);
	glVertex3f(20, 1, -55);
	glEnd();
	glPopMatrix();

	renderWhiteStripes(-20, 20, -60, 1);
	renderWhiteStripes(-20, 20, -65, 1);
	renderWhiteStripes(-20, 20, -70, 1);
	renderWhiteStripes(-20, 20, -75, 1);
	renderWhiteStripes(-20, 20, -80, 1);
	renderWhiteStripes(-20, 20, -85, 1);
	renderWhiteStripes(-20, 20, -90, 1);
	renderWhiteStripes(-20, 20, -95, 1);
	renderWhiteStripes(-20, 20, -100, 1);

	//Fifth Black Road
	glPushMatrix();
	glBegin(GL_QUADS);
	glColor3f(0, 0, 0);
	glNormal3f(0, 1, 0);
	glVertex3f(-20, 1.3, -55);
	glVertex3f(-20, 1.3, -105);
	glVertex3f(20, 1.3, -105);
	glVertex3f(20, 1.3, -55);
	glEnd();
	glPopMatrix();

	glColor3f(1, 1, 1);

	drawBush(-16, -3);
	drawBush(7, -3);
	drawBush(-12, -22);
	drawBush(-16, -23);
	drawBush(7, -43);
	drawBush(-14, -52);
	drawBush(14, -115);
	//drawBush(14, -125);
	drawBush(14, -135);
	//drawBush(14, -145);
	drawBush(14, -155);
	//drawBush(14, -165);
	drawBush(14, -175);
	//drawBush(-14, -115);
	drawBush(-14, -125);
	//drawBush(-14, -135);
	drawBush(-14, -145);
	//drawBush(-14, -155);
	drawBush(-14, -165);
	//drawBush(-14, -175);


	glPushMatrix();
	glTranslatef(-18, 0, 20);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(15, 0, 22);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-18, 0, -2);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-8, 0, -3);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(15, 0, -4);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();


	glPushMatrix();
	glTranslatef(5, 0, -22);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(10, 0, -23);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();


	glPushMatrix();
	glTranslatef(0, 0, -24);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(-18, 0, -43);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	glPushMatrix();
	glTranslatef(18, 0, -53);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	/*glPushMatrix();
	glTranslatef(-18, 0, -110);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();*/

	glPushMatrix();
	glTranslatef(-18, 0, -120);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	/*glPushMatrix();
	glTranslatef(-18, 0, -130);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();*/

	glPushMatrix();
	glTranslatef(-18, 0, -140);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	/*glPushMatrix();
	glTranslatef(-18, 0, -150);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();
	*/
	glPushMatrix();
	glTranslatef(-18, 0, -160);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	/*glPushMatrix();
	glTranslatef(-18, 0, -170);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();*/


	glPushMatrix();
	glTranslatef(18, 0, -110);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	/*glPushMatrix();
	glTranslatef(18, 0, -120);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();*/

	glPushMatrix();
	glTranslatef(18, 0, -130);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	/*glPushMatrix();
	glTranslatef(18, 0, -140);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();*/

	glPushMatrix();
	glTranslatef(18, 0, -150);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

	/*glPushMatrix();
	glTranslatef(18, 0, -160);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();*/

	glPushMatrix();
	glTranslatef(18, 0, -170);
	glScalef(0.7, 0.7, 0.7);
	model_tree.Draw();
	glPopMatrix();

}

void setupLights(){
	GLfloat lightIntensity[] = { lightx, lighty, lightz, 1.0f };
	GLfloat lightPosition[] = { -40.0f, 100.0f, -40.0f, 0.0f };
	glPushMatrix();
	// rotating the light
	glRotated(angle, 1, 0, 0);
	glRotated(angle1, 0, 0, 1);
	glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
	glLightfv(GL_LIGHT0, GL_AMBIENT, lightIntensity);
	glPopMatrix();
}
void traceCam(){
	printf("position x %f position y %f position z %f Dir x %f Dir y %f Dir z %f\n", camera.eye.x, camera.eye.y, camera.eye.z, camera.center.x, camera.center.y, camera.center.z);

}

void awesomeFrog(){
	//frog


	glPushMatrix();


	glTranslated(frogx, frogy, frogz); //starting xyz
	glScaled(0.5, 0.5, 0.5);
	glRotated(frogrotation, 0, 1, 0);	//used for frog rotation

	glPushMatrix();

	GLUquadricObj * frog;
	frog = gluNewQuadric();
	glTranslated(0, 4, 0);
	glBindTexture(GL_TEXTURE_2D, fskin);
	gluQuadricTexture(frog, true);
	gluQuadricNormals(frog, GL_SMOOTH);
	gluSphere(frog, 1, 50, 50);
	gluDeleteQuadric(frog);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * froghead;
	froghead = gluNewQuadric();
	glTranslated(0, 5, 1);
	glBindTexture(GL_TEXTURE_2D, fskin);
	gluQuadricTexture(froghead, true);
	gluQuadricNormals(froghead, GL_SMOOTH);
	gluSphere(froghead, 0.7, 50, 50);
	gluDeleteQuadric(froghead);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogeye;
	frogeye = gluNewQuadric();
	glTranslated(0, 5.5, 1.4);
	glRotated(-35, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, feyes);
	gluQuadricTexture(frogeye, true);
	gluQuadricNormals(frogeye, GL_SMOOTH);
	gluSphere(frogeye, 0.3, 50, 50);
	gluDeleteQuadric(frogeye);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogeye2;
	frogeye2 = gluNewQuadric();
	glTranslated(0.5, 5.5, 1.2);
	glRotated(-35, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, feyes);
	gluQuadricTexture(frogeye2, true);
	gluQuadricNormals(frogeye2, GL_SMOOTH);
	gluSphere(frogeye2, 0.3, 50, 50);
	gluDeleteQuadric(frogeye2);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognose;
	frognose = gluNewQuadric();
	glTranslated(0.2, 5.1, 1.7);
	glBindTexture(GL_TEXTURE_2D, feet);
	gluQuadricTexture(frognose, true);
	gluQuadricNormals(frognose, GL_SMOOTH);
	gluSphere(frognose, 0.07, 50, 50);
	gluDeleteQuadric(frognose);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognose2;
	frognose2 = gluNewQuadric();
	glTranslated(0.5, 5.1, 1.5);
	glBindTexture(GL_TEXTURE_2D, feet);
	gluQuadricTexture(frognose2, true);
	gluQuadricNormals(frognose2, GL_SMOOTH);
	gluSphere(frognose2, 0.07, 50, 50);
	gluDeleteQuadric(frognose2);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogmouth;
	frogmouth = gluNewQuadric();
	glTranslated(-0.2, 4.8, 1.7);
	glRotated(180, 1, 0, 1);
	glRotated(270, 0, 0, 1);
	glBindTexture(GL_TEXTURE_2D, feet);
	gluQuadricTexture(frogmouth, true);
	gluQuadricNormals(frogmouth, GL_SMOOTH);
	gluCylinder(frogmouth, 0.07, 0.1, 0.8, 10, 10);
	gluDeleteQuadric(frogmouth);

	glPopMatrix();

	glPushMatrix();
	glRotated(armrotation, 1, 0, 0); //rotation inside matrix of arm

	glPushMatrix();

	GLUquadricObj * frogarm;
	frogarm = gluNewQuadric();
	glTranslated(-0.3, 4, 0.9);
	glRotated(90, 1, 0, 0);
	glRotated(-20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frogarm, true);
	gluQuadricNormals(frogarm, GL_SMOOTH);
	gluCylinder(frogarm, 0.1, 0.1, 0.7, 10, 10);
	gluDeleteQuadric(frogarm);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogarm2;
	frogarm2 = gluNewQuadric();
	glTranslated(-0.55, 3.4, 0.9);
	glRotated(90, 1, 0, 0);
	glRotated(20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frogarm2, true);
	gluQuadricNormals(frogarm2, GL_SMOOTH);
	gluCylinder(frogarm2, 0.1, 0.1, 0.7, 10, 10);
	gluDeleteQuadric(frogarm2);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogarm2s;
	frogarm2s = gluNewQuadric();
	glTranslated(-0.55, 3.4, 0.9);
	glRotated(90, 1, 0, 0);
	glRotated(20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frogarm2s, true);
	gluQuadricNormals(frogarm2s, GL_SMOOTH);
	gluSphere(frogarm2s, 0.1, 100, 100);
	gluDeleteQuadric(frogarm2s);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogarmS;
	frogarmS = gluNewQuadric();
	glTranslated(-0.31, 2.75, 0.9);
	glRotated(90, 1, 0, 0);
	glRotated(20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frogarmS, true);
	gluQuadricNormals(frogarmS, GL_SMOOTH);
	gluSphere(frogarmS, 0.1, 100, 100);
	gluDeleteQuadric(frogarmS);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogfinger;
	frogfinger = gluNewQuadric();
	glTranslated(-0.31, 2.75, 0.9);
	glRotated(-20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frogfinger, true);
	gluQuadricNormals(frogfinger, GL_SMOOTH);
	gluCylinder(frogfinger, 0.075, 0.075, 0.2, 10, 10);
	gluDeleteQuadric(frogfinger);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogfingerS;
	frogfingerS = gluNewQuadric();
	glTranslated(-0.39, 2.75, 1.1);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frogfingerS, true);
	gluQuadricNormals(frogfingerS, GL_SMOOTH);
	gluSphere(frogfingerS, 0.075, 100, 100);
	gluDeleteQuadric(frogfingerS);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogfinger2;
	frogfinger2 = gluNewQuadric();
	glTranslated(-0.31, 2.75, 0.9);
	glRotated(20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frogfinger2, true);
	gluQuadricNormals(frogfinger2, GL_SMOOTH);
	gluCylinder(frogfinger2, 0.075, 0.075, 0.2, 10, 10);
	gluDeleteQuadric(frogfinger2);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogfinger2S;
	frogfinger2S = gluNewQuadric();
	glTranslated(-0.235, 2.75, 1.1);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frogfinger2S, true);
	gluQuadricNormals(frogfinger2S, GL_SMOOTH);
	gluSphere(frogfinger2S, 0.075, 100, 100);
	gluDeleteQuadric(frogfinger2S);

	glPopMatrix();

	//--------

	glPushMatrix();

	GLUquadricObj * frogarmright;
	frogarmright = gluNewQuadric();
	glTranslated(0.3, 4, 0.9);
	glRotated(90, 1, 0, 0);
	glRotated(20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frogarmright, true);
	gluQuadricNormals(frogarmright, GL_SMOOTH);
	gluCylinder(frogarmright, 0.1, 0.1, 0.7, 10, 10);
	gluDeleteQuadric(frogarmright);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogarm2right;
	frogarm2right = gluNewQuadric();
	glTranslated(0.55, 3.4, 0.9);
	glRotated(90, 1, 0, 0);
	glRotated(-20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frogarm2right, true);
	gluQuadricNormals(frogarm2right, GL_SMOOTH);
	gluCylinder(frogarm2right, 0.1, 0.1, 0.7, 10, 10);
	gluDeleteQuadric(frogarm2right);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogarm2sright;
	frogarm2sright = gluNewQuadric();
	glTranslated(0.55, 3.4, 0.9);
	glRotated(90, 1, 0, 0);
	glRotated(20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frogarm2sright, true);
	gluQuadricNormals(frogarm2sright, GL_SMOOTH);
	gluSphere(frogarm2sright, 0.1, 100, 100);
	gluDeleteQuadric(frogarm2sright);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogarmSright;
	frogarmSright = gluNewQuadric();
	glTranslated(0.31, 2.75, 0.9);
	glRotated(90, 1, 0, 0);
	glRotated(20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frogarmSright, true);
	gluQuadricNormals(frogarmSright, GL_SMOOTH);
	gluSphere(frogarmSright, 0.1, 100, 100);
	gluDeleteQuadric(frogarmSright);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogfingerright;
	frogfingerright = gluNewQuadric();
	glTranslated(0.31, 2.75, 0.9);
	glRotated(-20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frogfingerright, true);
	gluQuadricNormals(frogfingerright, GL_SMOOTH);
	gluCylinder(frogfingerright, 0.075, 0.075, 0.2, 10, 10);
	gluDeleteQuadric(frogfingerright);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogfingerSright;
	frogfingerSright = gluNewQuadric();
	glTranslated(0.39, 2.75, 1.1);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frogfingerSright, true);
	gluQuadricNormals(frogfingerSright, GL_SMOOTH);
	gluSphere(frogfingerSright, 0.075, 100, 100);
	gluDeleteQuadric(frogfingerSright);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogfinger2right;
	frogfinger2right = gluNewQuadric();
	glTranslated(0.31, 2.75, 0.9);
	glRotated(20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frogfinger2right, true);
	gluQuadricNormals(frogfinger2right, GL_SMOOTH);
	gluCylinder(frogfinger2right, 0.075, 0.075, 0.2, 10, 10);
	gluDeleteQuadric(frogfinger2right);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frogfinger2Sright;
	frogfinger2Sright = gluNewQuadric();
	glTranslated(0.435, 2.75, 1.1);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frogfinger2Sright, true);
	gluQuadricNormals(frogfinger2Sright, GL_SMOOTH);
	gluSphere(frogfinger2Sright, 0.075, 100, 100);
	gluDeleteQuadric(frogfinger2Sright);

	glPopMatrix();

	glPopMatrix();

	glPushMatrix();
	glRotated(legrotation, 1, 0, 0); //rotation inside matrix of legs

	glPushMatrix();

	GLUquadricObj * frognewleg;
	frognewleg = gluNewQuadric();
	glTranslated(0.8, 3.3, -0.2);
	glRotated(-20, 1, 0, 0);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frognewleg, true);
	gluQuadricNormals(frognewleg, GL_SMOOTH);
	gluCylinder(frognewleg, 0.125, 0.125, 1, 10, 10);
	gluDeleteQuadric(frognewleg);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognewleg2;
	frognewleg2 = gluNewQuadric();
	glTranslated(0.8, 3.3, -0.2);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frognewleg2, true);
	gluQuadricNormals(frognewleg2, GL_SMOOTH);
	gluSphere(frognewleg2, 0.125, 100, 100);
	gluDeleteQuadric(frognewleg2);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognewleg4;
	frognewleg4 = gluNewQuadric();
	glTranslated(0.8, 3.6, 0.7);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frognewleg4, true);
	gluQuadricNormals(frognewleg4, GL_SMOOTH);
	gluSphere(frognewleg4, 0.125, 100, 100);
	gluDeleteQuadric(frognewleg4);

	glPopMatrix();


	glPushMatrix();

	GLUquadricObj * frognewleg3;
	frognewleg3 = gluNewQuadric();
	glTranslated(0.8, 3.3, -0.2);
	glRotated(20, 1, 0, 0);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frognewleg3, true);
	gluQuadricNormals(frognewleg3, GL_SMOOTH);
	gluCylinder(frognewleg3, 0.125, 0.125, 1, 10, 10);
	gluDeleteQuadric(frognewleg3);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognewleg5;
	frognewleg5 = gluNewQuadric();
	glTranslated(0.8, 3, 0.7);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frognewleg5, true);
	gluQuadricNormals(frognewleg5, GL_SMOOTH);
	gluSphere(frognewleg5, 0.125, 100, 100);
	gluDeleteQuadric(frognewleg5);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognewtoe;
	frognewtoe = gluNewQuadric();
	glTranslated(0.8, 3, 0.7);
	glRotated(20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frognewtoe, true);
	gluQuadricNormals(frognewtoe, GL_SMOOTH);
	gluCylinder(frognewtoe, 0.075, 0.075, 0.4, 10, 10);
	gluDeleteQuadric(frognewtoe);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognewtoes;
	frognewtoes = gluNewQuadric();
	glTranslated(0.7, 3, 1);
	glRotated(20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frognewtoes, true);
	gluQuadricNormals(frognewtoes, GL_SMOOTH);
	gluSphere(frognewtoes, 0.075, 100, 100);
	gluDeleteQuadric(frognewtoes);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognewtoe2;
	frognewtoe2 = gluNewQuadric();
	glTranslated(0.8, 3, 0.7);
	glRotated(-20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frognewtoe2, true);
	gluQuadricNormals(frognewtoe2, GL_SMOOTH);
	gluCylinder(frognewtoe2, 0.075, 0.075, 0.4, 10, 10);
	gluDeleteQuadric(frognewtoe2);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognewtoe2s;
	frognewtoe2s = gluNewQuadric();
	glTranslated(0.94, 3, 1.09);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frognewtoe2s, true);
	gluQuadricNormals(frognewtoe2s, GL_SMOOTH);
	gluSphere(frognewtoe2s, 0.075, 100, 100);
	gluDeleteQuadric(frognewtoe2s);

	glPopMatrix();

	// ------------------------

	glPushMatrix();

	GLUquadricObj * frognewlegleft;
	frognewlegleft = gluNewQuadric();
	glTranslated(-0.7, 3.3, -0.2);
	glRotated(-20, 1, 0, 0);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frognewlegleft, true);
	gluQuadricNormals(frognewlegleft, GL_SMOOTH);
	gluCylinder(frognewlegleft, 0.125, 0.125, 1, 10, 10);
	gluDeleteQuadric(frognewlegleft);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognewleg2left;
	frognewleg2left = gluNewQuadric();
	glTranslated(-0.7, 3.3, -0.2);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frognewleg2left, true);
	gluQuadricNormals(frognewleg2left, GL_SMOOTH);
	gluSphere(frognewleg2left, 0.125, 100, 100);
	gluDeleteQuadric(frognewleg2left);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognewleg4left;
	frognewleg4left = gluNewQuadric();
	glTranslated(-0.7, 3.6, 0.7);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frognewleg4left, true);
	gluQuadricNormals(frognewleg4left, GL_SMOOTH);
	gluSphere(frognewleg4left, 0.125, 100, 100);
	gluDeleteQuadric(frognewleg4left);

	glPopMatrix();


	glPushMatrix();

	GLUquadricObj * frognewleg3left;
	frognewleg3left = gluNewQuadric();
	glTranslated(-0.7, 3.3, -0.2);
	glRotated(20, 1, 0, 0);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frognewleg3left, true);
	gluQuadricNormals(frognewleg3left, GL_SMOOTH);
	gluCylinder(frognewleg3, 0.125, 0.125, 1, 10, 10);
	gluDeleteQuadric(frognewleg3left);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognewleg5left;
	frognewleg5left = gluNewQuadric();
	glTranslated(-0.7, 3, 0.7);
	glBindTexture(GL_TEXTURE_2D, flegs);
	gluQuadricTexture(frognewleg5left, true);
	gluQuadricNormals(frognewleg5left, GL_SMOOTH);
	gluSphere(frognewleg5left, 0.125, 100, 100);
	gluDeleteQuadric(frognewleg5left);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognewtoeleft;
	frognewtoeleft = gluNewQuadric();
	glTranslated(-0.7, 3, 0.7);
	glRotated(20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frognewtoeleft, true);
	gluQuadricNormals(frognewtoeleft, GL_SMOOTH);
	gluCylinder(frognewtoeleft, 0.075, 0.075, 0.4, 10, 10);
	gluDeleteQuadric(frognewtoeleft);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognewtoesleft;
	frognewtoesleft = gluNewQuadric();
	glTranslated(-0.6, 3, 1);
	glRotated(20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frognewtoesleft, true);
	gluQuadricNormals(frognewtoesleft, GL_SMOOTH);
	gluSphere(frognewtoesleft, 0.075, 100, 100);
	gluDeleteQuadric(frognewtoesleft);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognewtoe2left;
	frognewtoe2left = gluNewQuadric();
	glTranslated(-0.7, 3, 0.7);
	glRotated(-20, 0, 1, 0);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frognewtoe2left, true);
	gluQuadricNormals(frognewtoe2left, GL_SMOOTH);
	gluCylinder(frognewtoe2left, 0.075, 0.075, 0.4, 10, 10);
	gluDeleteQuadric(frognewtoe2left);

	glPopMatrix();

	glPushMatrix();

	GLUquadricObj * frognewtoe2sleft;
	frognewtoe2sleft = gluNewQuadric();
	glTranslated(-0.84, 3, 1.09);
	glBindTexture(GL_TEXTURE_2D, dskin);
	gluQuadricTexture(frognewtoe2sleft, true);
	gluQuadricNormals(frognewtoe2sleft, GL_SMOOTH);
	gluSphere(frognewtoe2sleft, 0.075, 100, 100);
	gluDeleteQuadric(frognewtoe2sleft);

	glPopMatrix();

	glPopMatrix();

	glPopMatrix();


}
void modifyModel(int direction, int model){


	switch (model){
	case 0:direction == 1 ? glRotated(90, 0, 1, 0) : glRotated(-90, 0, 1, 0); break;
	case 1:direction == 1 ? glRotated(90, 0, 1, 0) : glRotated(-90, 0, 1, 0); break;
	case 2:direction == -1 ? glRotated(-180, 0, 1, 0) : true; break;
	case 3:direction == 1 ? glRotated(90, 0, 1, 0) : glRotated(-90, 0, 1, 0);  glScaled(2, 2, 2); break;
	case 4:direction == 1 ? glRotated(-90, 0, 1, 0) : glRotated(90, 0, 1, 0); glScaled(30, 30, 30); break;
	case 5:direction == 1 ? glRotated(180, 0, 1, 0) : true; glTranslated(0, 1, 0); glScaled(1, 1, 1.5); break;
	case 6:direction == 1 ? glRotated(90, 0, 1, 0) : glRotated(-90, 0, 1, 0); glTranslated(0, 1, 0); glScaled(70, 70, 70); break;
	case 7:direction == 1 ? glRotated(90, 0, 1, 0) : glRotated(-90, 0, 1, 0); glScaled(0.02, 0.02, 0.02); break;
	case 8:direction == 1 ? glRotated(90, 0, 1, 0) : glRotated(-90, 0, 1, 0); glScaled(70, 70, 70); break;
	case 9:direction == 1 ? glRotated(180, 0, 1, 0) : true; glScaled(11, 11, 11); break;
	case 10:direction == 1 ? glRotated(-90, 0, 1, 0) : glRotated(90, 0, 1, 0); glScaled(0.3, 0.3, 0.3); glTranslated(0, 1.7, 0); break;
	}

}

void drawACar(int carPos){
	glPushMatrix();
	glTranslated(allCars[level-1][carPos].x, allCars[level-1][carPos].y, allCars[level-1][carPos].z);
	modifyModel(allCars[level - 1][carPos].direction, allCars[level - 1][carPos].modelNumber);

	glScaled(0.02, 0.03, 0.02);
	models[allCars[level-1][carPos].modelNumber].Draw();
	glPopMatrix();
}
/*
void drawCollisionCube(){
	glPushMatrix();
	glBegin(GL_QUADS);
	// top
	glColor3f(1.0f, 0.0f, 0.0f);
	glNormal3f(0.0f, 1.0f, 0.0f);
	glVertex3f(tempx + 2, tempy + 2, tempz + 1.5);
	glVertex3f(tempx + 2, tempy + 2, tempz - 1.5);
	glVertex3f(tempx - 2, tempy + 2, tempz - 1.5);
	glVertex3f(tempx - 2, tempy + 2, tempz + 1.5);

	glEnd();
	glPopMatrix();
}*/
void myDisplay(void)
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	setupLights();

	setupCamera();
	//traceCam();
	// Draw Ground

	renderGround();


	//sky box
	skyBox();
	//Level 1
	glPushMatrix();

	if (won){
		glPushMatrix();
		gluLookAt(
			camera.eye.x, camera.eye.y, camera.eye.z,
			camera.center.x, camera.center.y, camera.center.z,
			camera.up.x, camera.up.y, camera.up.z
			);
		glutPostRedisplay();
		char string[32];
		sprintf(string, "You Win");
		print(camera.eye.x, camera.eye.y, camera.eye.z, string);
		glPopMatrix();
		glutSwapBuffers();
		return;

	}
	switch (level){
	case 1:level1(); break;
	case 2:level2(); break;
	case 3:level3(); break;
	case 4:level4(); break;
	case 5:level5(); break;
	}
	glPopMatrix();

	for (int i = 0; i < (sizeof(allCars[level-1]) / sizeof(*allCars[level-1])); i++){
		if (allCars[level-1][i].drawable&&allCars[level-1][i].direction!=0)
			drawACar(i);
	}

	awesomeFrog();


	char string[32];
	sprintf(string, "%d", currentLevelScore + totalScore);
	if (perspective==3)
		print(frogx+1, frogy + 4, frogz, string);
	else
		print(frogx-2, frogy+3, frogz-3, string);


	glutSwapBuffers();
}



//=======================================================================
// Mouse Function
//=======================================================================


void devKeyboard(unsigned char key, int x, int y) {
	float d = 1;

	switch (key) {
	case 'w':
		camera.moveY(d);
		break;
	case 's':
		camera.moveY(-d);
		break;
	case 'a':
		camera.moveX(d);
		break;
	case 'd':
		camera.moveX(-d);
		break;
	case 'q':
		camera.moveZ(d);
		break;
	case 'e':
		camera.moveZ(-d);
		break;
	case 'l':	//TODO: move Later to normal keyboard function
		legrotation--;
		armrotation++;
		break;
	case 'k':
		legrotation++;
		armrotation--;
		break;
	case 'u':
		movement++;
		break;
		/*case 'd':
		movement--;
		break;*/
	case GLUT_KEY_ESCAPE:
		exit(EXIT_SUCCESS);
	}

	glutPostRedisplay();
}
void devSpecial(int key, int x, int y) {
	float a = 1.0;

	switch (key) {
	case GLUT_KEY_UP:
		camera.rotateX(a);
		break;
	case GLUT_KEY_DOWN:
		camera.rotateX(-a);
		break;
	case GLUT_KEY_LEFT:
		camera.rotateY(a);
		break;
	case GLUT_KEY_RIGHT:
		camera.rotateY(-a);
		break;
	}

	glutPostRedisplay();
}
void mainSpecial(int key, int x, int y){

}


//=======================================================================
// Reshape Function
//=======================================================================
//TODO : REMOVE
void myReshape(int w, int h)
{
	if (h == 0) {
		h = 1;
	}

	WIDTH = w;
	HEIGHT = h;

	// set the drawable region of the window
	glViewport(0, 0, w, h);

	// set up the projection matrix
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(fovy, (GLdouble)WIDTH / (GLdouble)HEIGHT, zNear, zFar);

	// go back to modelview matrix so we can move the objects about
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	//TODO:Reshape camera ?
}

//=======================================================================
// Assets Loading Function
//=======================================================================
void LoadAssets()
{


	// Loading texture files

	loadBMP(&tex, "Textures/sky4-jpg.bmp", true);
	loadBMP(&ground, "Textures/ground.bmp", true);
	loadBMP(&fskin, "Textures/fskin2.bmp", true);
	loadBMP(&fneck, "Textures/frogneck.bmp", true);
	loadBMP(&feyes, "Textures/frogeyes2.bmp", true);
	loadBMP(&feet, "Textures/fryfoot.bmp", true);
	loadBMP(&dskin, "Textures/docskin.bmp", true);
	loadBMP(&flegs, "Textures/froglegs.bmp", true);

	//Cars
	model_car.Load("Models/car/Car nissan skyline gtr (bnr34) N080615.3ds");
	model_truck.Load("Models/truck/Car PickUpTruck EU N260614.3ds");
	model_police.Load("Models/police/NYPD.3ds");
	model_batcar.Load("Models/batcar/batcar.3ds");
	model_tank.Load("Models/tank/fv510.3ds");
	model_gallardo.Load("Models/lamborghini/gallardo.3ds");
	model_ferrari.Load("Models/ferrari/california.3ds");
	model_bike.Load("Models/bike/bike.3DS");
	model_Camaro.Load("Models/camaro/CAMARO.3ds");
	model_trophy.Load("Models/trophy/trophy.3ds");
	model_aston.Load("Models/aston/martin.3ds");




	model_bushes.Load("Models/Bushes/Bushes.3ds");
	model_tree2.Load("Models/tree2/mangrovetree.3ds");
	model_tree.Load("Models/tree/Tree1.3ds");
	models[0] = model_car;
	models[1] = model_truck;
	models[2] = model_police;
	models[3] = model_batcar;
	models[4] = model_tank;
	models[5] = model_gallardo;
	models[6] = model_ferrari;
	models[7] = model_bike;
	models[8] = model_Camaro;
	models[9] = model_trophy;
	models[10] = model_aston;

}

void initalizeCar(int level,int car ,float x , float y ,float z ,int direction,int timeToLive,int timeToStart,int modelNumber,float speed){
	allCars[level-1][car].y = y == -1 ? 1.3: y;
	allCars[level-1][car].z = z;
	allCars[level-1][car].timeToLive = timeToLive == -1 ? 100 : timeToLive;
	allCars[level-1][car].x = x;
	allCars[level-1][car].direction = direction;
	allCars[level-1][car].timeToStart = timeToStart;
	allCars[level-1][car].modelNumber = modelNumber;
	allCars[level - 1][car].speed = speed;

}
void AllCarsDisplay(){
	initalizeCar(2, 0, 20, -1, -5, -1, -1, 10, 0, 1); // Car moving to right starting at Z = -3
	initalizeCar(2, 1, 20, -1, -10, -1, -1, 10, 1, 1); // Car moving to right starting at Z = -5
	initalizeCar(2, 2, 20, -1, -15, -1, -1, 10, 2, 1); // Car moving to right starting at Z = -5
	initalizeCar(2, 3, 20, -1, -20, -1, -1, 10, 3, 1); // Car moving to right starting at Z = -5
	initalizeCar(2, 4, 20, -1, -25, -1, -1, 10, 4, 1); // Car moving to right starting at Z = -5

	initalizeCar(2, 5, 20, -1, -30, -1, -1, 10, 5, 1); // Car moving to right starting at Z = -5

	initalizeCar(2, 6, 20, -1, -35, -1, -1, 10, 6, 1); // Car moving to right starting at Z = -5
	initalizeCar(2, 7, 20, -1, -40, -1, -1, 10, 7, 1); // Car moving to right starting at Z = -5
	initalizeCar(2, 8, 20, -1, -45, -1, -1, 10, 8, 1); // Car moving to right starting at Z = -5
	initalizeCar(2, 9, 20, -1, -50, -1, -1, 10, 9, 1); // Car moving to right starting at Z = -5
	initalizeCar(2, 10, 20, -1, -55, -1, -1, 10, 10, 1); // Car moving to right starting at Z = -5
}

void initalizeLevel1Cars(){
			//  Level , Car , X , Y , Z , Direction , TTL , TTS,Model,Speed
	initalizeCar(1,0, -20, -1, -3, 1, 80, 10, 0,2); // Car moving to right starting at Z = -3
	initalizeCar(1,1, 20, -1, -8, -1, 70, 20, 0,2);  // Car moving to the left starting at Z = -8
	initalizeCar(1,2, 20, -1, -22, -1, 70, 40, 1,2); // Car moving to the left starting at Z = -22
	initalizeCar(1,3, -20, -1, -30, 1, 70, 50, 1,2); // Car moving to the right starting at Z = -30
	initalizeCar(1,4, 20, -1, -39, -1, 50, 60, 1,2); // Car moving to the left  starting at Z = -39

}
void initalizeLevel2Cars(){
	initalizeCar(2, 0, -20, -1, 8, 1, 15, 5, 2, 4); // Car moving to right starting at Z = 8

	initalizeCar(2, 1, -20, -1, -1, 1, 23, 10, 3, 3);  // Car moving to the left starting at Z = -1
	initalizeCar(2, 2, 20, -1, -8, -1, 23, 5, 3, 3);  // Car moving to the left starting at Z = -8

	initalizeCar(2, 3, -20, -1, -22, 1, 30, 10, 2, 2);  // Car moving to the left starting at Z = -1
	initalizeCar(2, 4, -20, -1, -27, 1, 30, 5, 3, 2);  // Car moving to the left starting at Z = -8
	initalizeCar(2, 5, 20, -1, -32.5, -1, 30, 10, 2, 2);  // Car moving to the left starting at Z = -1
	initalizeCar(2, 6, 20, -1, -38, -1, 30, 5, 3, 2);  // Car moving to the left starting at Z = -8

}
void initalizeLevel3Cars(){
	initalizeCar(3, 0, -20, -1, 12, 1, 15, 5, 4, 4);
	initalizeCar(3, 1, 20, -1, 8, -1, 34, 5, 5, 2);
	initalizeCar(3, 2, 20, -1, 3, -1, 36, 1, 4, 2.5);


	initalizeCar(3, 3, 20, -1, -8, -1, 17, 3, 5, 3);
	initalizeCar(3, 5,- 20, -1, -12, 1, 36, 1, 4, 2);

	initalizeCar(3, 6, 20, -1, -27, -1, 30, 8, 4, 2.5);
	initalizeCar(3, 7, -20, -1, -32, 1, 40, 1, 5, 2);
	initalizeCar(3, 8, 20, -1, -37, -1, 30, 3, 4, 2.5);
	initalizeCar(3, 9, 20, -1, -42, -1, 37, 2, 4, 2);
	initalizeCar(3, 9, -20, -1, -47, 1, 37, 2, 5, 2);

}
void initalizeLevel4Cars(){

}
void initalizeLevel5Cars(){

}
void initalizeAllCars(){
	initalizeLevel1Cars();
	initalizeLevel2Cars();
	initalizeLevel3Cars();
	initalizeLevel4Cars();
	initalizeLevel5Cars();


}
void initalizeFrog(){

	 frogx = 1;
	 frogy = 0;
	 frogz = 20;
	 frogbezier1[0] = 10; //calling random bezier curve values at start mostly helpful to set y = 0
	 frogbezier1[1] = 0;
	 frogbezier2[0] = 9;
	 frogbezier2[1] = 4;
	 frogbezier3[0] = 7;
	 frogbezier3[1] = 4;
	 frogbezier4[0] = 5;
	 frogbezier4[1] = 0;

}
void initalizeLevels(){
	finalZs[0]=-45;
	finalZs[1]=-41;
	finalZs[2]=-52;
	finalZs[3]=-77;
	finalZs[4]=-106;

}
//=======================================================================
// Main Function
//=======================================================================
void main(int argc, char** argv)
{
	glutInit(&argc, argv);

	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

	glutInitWindowSize(WIDTH, HEIGHT);

	glutInitWindowPosition(100, 150);

	glutCreateWindow(title);
	initalizeAllCars();
	initalizeFrog();
	initalizeLevels();
	glutDisplayFunc(myDisplay);
	legrotation = 0;

	frogflagjump = false; // set to false so we can enter first movement command
	if (developerMode){
		glutKeyboardFunc(devKeyboard);
		glutSpecialFunc(devSpecial);
	}
	else{

			glutKeyboardFunc(FrogKeyboard);
			glutSpecialFunc(mainSpecial);

	}
	Sleep(1000);

	glutReshapeFunc(myReshape);
	glutTimerFunc(0, timeF, 0);
	glutIdleFunc(Anim);
	myInit();

	LoadAssets();


	glEnable(GL_DEPTH_TEST);
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);
	glEnable(GL_NORMALIZE);
	glEnable(GL_COLOR_MATERIAL);

	glShadeModel(GL_SMOOTH);

	glutMainLoop();
}


void frogbezier(int value){
	if (frogtimer < 1){


		int *f3 = bezier(frogtimer, frogbezier1, frogbezier2, frogbezier3, frogbezier4); //call bezier
		frogcoord[0] = f3[0];
		frogz = frogcoord[0]; //set z to bezier values because we are moving forwards
		frogcoord[1] = f3[1];
		frogy = frogcoord[1];
		frogtimer = frogtimer + 0.095;//initial 0.035
		if (hit){
			initalizeFrog();
		}
		glutPostRedisplay();

	}
	else{
		frogtimer = 0; //restart leg and arm timer
		frogflagjump = false;	// allow another movement command to be made
	}
	if (frogflagjump){
		glutTimerFunc(0.0001, frogbezier, 0); //stop calling timer after we finish the jump
	}
}
void frogbezierlft(int value){
	if (frogtimer < 1){


		int *f3 = bezier(frogtimer, frogbezier1, frogbezier2, frogbezier3, frogbezier4);
		frogcoord[0] = f3[0];
		frogx = frogcoord[0]; // set x to bezier values because we are moving left
		frogcoord[1] = f3[1];
		frogy = frogcoord[1];
		frogtimer = frogtimer + 0.095;
		if (hit){
			initalizeFrog();
		}
		glutPostRedisplay();

	}
	else{
		frogtimer = 0;	//restart leg and arm timer
		frogflagjump = false;	// allow another movement command to be made
	}
	if (frogflagjump){
		glutTimerFunc(0.0001, frogbezierlft, 0); //stop calling timer after we finish the jump
	}
}
void frogbezierrght(int value){
	if (frogtimer < 1){


		int *f3 = bezier(frogtimer, frogbezier1, frogbezier2, frogbezier3, frogbezier4);
		frogcoord[0] = f3[0];
		frogx = frogcoord[0]; // set x to bezier values because we are moving right
		frogcoord[1] = f3[1];
		frogy = frogcoord[1];
		frogtimer = frogtimer + 0.095;
		if (hit){
			initalizeFrog();
		}
		glutPostRedisplay();

	}
	else{
		frogtimer = 0;	//restart leg and arm timer
		frogflagjump = false;	// allow another movement command to be made
	}
	if (frogflagjump){
		glutTimerFunc(0.0001, frogbezierrght, 0); //stop calling timer after we finish the jump
	}
}
void frogbezierbck(int value){
	if (frogtimer < 1){


		int *f3 = bezier(frogtimer, frogbezier1, frogbezier2, frogbezier3, frogbezier4);
		frogcoord[0] = f3[0];
		frogz = frogcoord[0]; //set z to bezier values because we are moving backwards
		frogcoord[1] = f3[1];
		frogy = frogcoord[1];
		frogtimer = frogtimer + 0.095;
		if (hit){
			initalizeFrog();
		}
		glutPostRedisplay();

	}
	else{
		frogtimer = 0;	//restart leg and arm timer
		frogflagjump = false;	// allow another movement command to be made
	}
	if (frogflagjump){
		glutTimerFunc(0.0001, frogbezierbck, 0); //stop calling timer after we finish the jump
	}
}
void frogTimer(int value) { // movement of arms and legs


	if (enablefrog){
		if (flaglegA == true && legrotation > -19){ //can be adjusted on how much we want to go back and forth
			legrotation = legrotation - 1;
			armrotation = armrotation - 0.5;
		}
		else if (legrotation != 0){
			flaglegA = false;
			legrotation = legrotation + 1;
			armrotation = armrotation + 0.5;
		}
		glutPostRedisplay();
		glutTimerFunc(30, frogTimer, 0);
		glutPostRedisplay();
	}

}
int* bezier(float t, int* p0, int* p1, int* p2, int* p3) // bezier curve from bezier.cpp
{
	int res[2];
	res[0] = pow((1 - t), 3)*p0[0] + 3 * t*pow((1 - t), 2)*p1[0] + 3 * pow(t, 2)*(1 - t)*p2[0] + pow(t, 3)*p3[0];
	res[1] = pow((1 - t), 3)*p0[1] + 3 * t*pow((1 - t), 2)*p1[1] + 3 * pow(t, 2)*(1 - t)*p2[1] + pow(t, 3)*p3[1];
	return res;
}
void FrogKeyboard(unsigned char button, int x, int y)
{
	float d = 2;
	if (won){
		glutPostRedisplay();
		return;
	}
		switch (button)
	{
	case 'w':
		if (frogflagjump == false){ // if we are not in another movement state enter
			enablefrog = true; //enter leg and arm movement
			hit = false;
			legrotation = 0;
			armrotation = 0;
			flaglegA = true;
			frogflagjump = true;
			frogbezier1[0] = frogz; //start from z
			frogbezier2[0] = frogz - 1;
			frogbezier3[0] = frogz - 3;
			frogbezier4[0] = frogz - 5; //end at z-5
			glutTimerFunc(1, frogTimer, 0);
			glutTimerFunc(1, frogbezier, 0);
			camera.look(frogx, frogy, frogz,perspective,xValue);
			PlaySound("jump34.wav", NULL, SND_ASYNC | SND_FILENAME);
		}

		break;
	case 's':
		if (frogflagjump == false&&frogz<=21){ // if we are not in another movement state enter
			enablefrog = true; //enter leg and arm movement
			hit = false;
			legrotation = 0;
			armrotation = 0;
			flaglegA = true;
			frogflagjump = true;
			frogbezier1[0] = frogz; //start from z
			frogbezier2[0] = frogz + 5;
			frogbezier3[0] = frogz + 5;
			frogbezier4[0] = frogz + 5; //end at z+5
			glutTimerFunc(1, frogTimer, 0);
			glutTimerFunc(1, frogbezierbck, 0);
			camera.look(frogx, frogy, frogz,perspective,xValue);
			PlaySound("jump34.wav", NULL, SND_ASYNC | SND_FILENAME);
		}

		break;
	case 'a':
		if (frogflagjump == false&&frogx >= -18){ // if we are not in another movement state enter
			enablefrog = true; //enter leg and arm movement
			hit = false;
			legrotation = 0;
			armrotation = 0;
			flaglegA = true;
			frogflagjump = true;
			frogbezier1[0] = frogx; //start from x
			frogbezier2[0] = frogx - 1;
			frogbezier3[0] = frogx - 3;
			frogbezier4[0] = frogx - 5; //end at x-5
			glutTimerFunc(1, frogbezierlft, 0);
			glutTimerFunc(1, frogTimer, 0);
			PlaySound("jump34.wav", NULL, SND_ASYNC | SND_FILENAME);

		}

		break;
	case 'd':
		if (frogflagjump == false && frogx <= 18){ // if we are not in another movement state enter
			enablefrog = true; //enter leg and arm movement
			hit = false;
			legrotation = 0;
			armrotation = 0;
			flaglegA = true;
			frogflagjump = true;
			frogbezier1[0] = frogx; //start from x
			frogbezier2[0] = frogx + 1;
			frogbezier3[0] = frogx + 3;
			frogbezier4[0] = frogx + 5; //end at x+5
			glutTimerFunc(1, frogbezierrght, 0);
			glutTimerFunc(1, frogTimer, 0);
			PlaySound("jump34.wav", NULL, SND_ASYNC | SND_FILENAME);

		}
		break;
	case 'f':
		perspective = perspective == 3 ? 1 : 3; break;
	case'q':
		xValue -= 35; break;
	case'e':
		xValue += 35; break;
	case 27:
		exit(0);
		break;
	default:
		break;
	}


	glutPostRedisplay();
}
void Anim(){
	//rotating light equations
	alpha += 0.03;// adjust the speed from here
	angle = 90 * cos(alpha) + 7.5;
	angle1 = 90 * sin(alpha) + 7.5;
	glutPostRedisplay();
}
void drawBush(double x, double z){
	glPushMatrix();
	glTranslated(x, 1.3, z);
	glScaled(0.3, 0.3, 0.3);
	model_bushes.Draw();
	glPopMatrix();
}
void print(int x, int y, int z, char *string)
{
	glColor3f(1, 0, 0);
	//set the position of the text in the window using the x and y coordinates
	glRasterPos3f(x, y,z);
	//get the length of the string to display
	int len = (int)strlen(string);

	//loop to display character by character
	for (int i = 0; i < len; i++)
	{
		glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, string[i]);
	}
	glColor3f(1, 1, 1);
};