main.cpp

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

#include <windows.h>
#include <GL/glut.h>

#define pi (2*acos(0.0))

double cameraHeight;
double cameraAngle;
int drawgrid;
int drawaxes;
double angleTurn;
double angleFwd;

double wheelH = 8, wheelR = 12;

struct PT
{
	PT() {}
	double x,y,z;

	PT(double x, double y, double z) : x(x), y(y), z(z) {}
    PT(const PT &p) : x(p.x), y(p.y), z(p.z) {}

	// arithemtic operations
	PT operator +(PT b)  {return PT(x+b.x,y+b.y, z+b.z);}
    PT operator -(PT b)  {return PT(x-b.x,y-b.y, z-b.z);}
	PT operator *(double b)  {return PT(x*b,y*b, z*b);}
	PT operator /(double b)  {return PT(x/b,y/b, z/b);}
	PT operator *(PT b)  {return PT(y*b.z-z*b.y, z*b.x-x*b.z, x*b.y-y*b.x);}
};

// position of wheel
PT pos(0,0,0);

void drawAxes()
{
	if(drawaxes==1)
	{
		glColor3f(1.0, 1.0, 1.0);
		glBegin(GL_LINES);{
			glVertex3f( 100,0,0);
			glVertex3f(-100,0,0);

			glVertex3f(0,-100,0);
			glVertex3f(0, 100,0);

			glVertex3f(0,0, 100);
			glVertex3f(0,0,-100);
		}glEnd();
	}
}


void drawGrid()
{
	int i;
	if(drawgrid==1)
	{
		glColor3f(0.6, 0.6, 0.6);	//grey
		glBegin(GL_LINES);{
			for(i=-8;i<=8;i++){

				// if(i==0)
				// 	continue;	//SKIP the MAIN axes

				//lines parallel to Y-axis
				glVertex3f(i*10, -90, 0);
				glVertex3f(i*10,  90, 0);

				//lines parallel to X-axis
				glVertex3f(-90, i*10, 0);
				glVertex3f( 90, i*10, 0);
			}
		}glEnd();
	}
}

void drawSquare(double a)
{
    //glColor3f(1.0,0.0,0.0);
	glBegin(GL_QUADS);{
		glVertex3f( a, a,0);
		glVertex3f( a,-a,0);
		glVertex3f(-a,-a,0);
		glVertex3f(-a, a,0);
	}glEnd();
}

void drawRectangle(double w,double h,double z)
{
    //glColor3f(1.0,0.0,0.0);
	glBegin(GL_QUADS);{
		glVertex3f( w, h,z);
		glVertex3f( w,-h,z);
		glVertex3f(-w,-h,z);
		glVertex3f(-w, h,z);
	}glEnd();
}

void drawRectangleWheelUp1(double w,double h,double z)
{
    glColor3f(1.0,1.0,1.0);
	glBegin(GL_QUADS);{
		glVertex3f( w, h,z);
		glVertex3f( w,0,z);
		glVertex3f(-w,0,z);
		glVertex3f(-w, h,z);
	}glEnd();
}

void drawRectangleWheelUp2(double w,double h,double z)
{
    glColor3f(1.0,1.0,1.0);
	glBegin(GL_QUADS);{
		glVertex3f( w, 0,z);
		glVertex3f( w,-h,z);
		glVertex3f(-w,-h,z);
		glVertex3f(-w, 0,z);
	}glEnd();
}


void drawRectangleWheelUp3(double w,double h,double z)
{
    glColor3f(1.0,0.0,0.0);
	glBegin(GL_QUADS);{
		glVertex3f( w+2, h+2,z);
		glVertex3f( w+2, h-2,z);
		glVertex3f( w-2, h+2,z);
		glVertex3f( w-2, h-2,z);
	}glEnd();
}

void drawCircle(double radius,int segments)
{
    int i;
    struct PT points[100];
    glColor3f(0.7,0.7,0.7);
    //generate points
    for(i=0;i<=segments;i++)
    {
        points[i].x=radius*cos(((double)i/(double)segments)*2*pi);
        points[i].y=radius*sin(((double)i/(double)segments)*2*pi);
    }
    //draw segments using generated points
    for(i=0;i<segments;i++)
    {
        glBegin(GL_LINES);
        {
			glVertex3f(points[i].x,points[i].y,0);
			glVertex3f(points[i+1].x,points[i+1].y,0);
        }
        glEnd();
    }
}

void drawCone(double radius,double height,int segments)
{
    int i;
    double shade;
    struct PT points[100];
    //generate points
    for(i=0;i<=segments;i++)
    {
        points[i].x=radius*cos(((double)i/(double)segments)*2*pi);
        points[i].y=radius*sin(((double)i/(double)segments)*2*pi);
    }
    //draw triangles using generated points
    for(i=0;i<segments;i++)
    {
        //create shading effect
        if(i<segments/2)shade=2*(double)i/(double)segments;
        else shade=2*(1.0-(double)i/(double)segments);
        glColor3f(shade,shade,shade);

        glBegin(GL_TRIANGLES);
        {
            glVertex3f(0,0,height);
			glVertex3f(points[i].x,points[i].y,0);
			glVertex3f(points[i+1].x,points[i+1].y,0);
        }
        glEnd();
    }
}


void drawSphere(double radius,int slices,int stacks)
{
	struct PT points[100][100];
	int i,j;
	double h,r;
	//generate points
	for(i=0;i<=stacks;i++)
	{
		h=radius*sin(((double)i/(double)stacks)*(pi/2));
		r=radius*cos(((double)i/(double)stacks)*(pi/2));
		for(j=0;j<=slices;j++)
		{
			points[i][j].x=r*cos(((double)j/(double)slices)*2*pi);
			points[i][j].y=r*sin(((double)j/(double)slices)*2*pi);
			points[i][j].z=h;
		}
	}
	//draw quads using generated points
	for(i=0;i<stacks;i++)
	{
        glColor3f((double)i/(double)stacks,(double)i/(double)stacks,(double)i/(double)stacks);
		for(j=0;j<slices;j++)
		{
			glBegin(GL_QUADS);{
			    //upper hemisphere
				glVertex3f(points[i][j].x,points[i][j].y,points[i][j].z);
				glVertex3f(points[i][j+1].x,points[i][j+1].y,points[i][j+1].z);
				glVertex3f(points[i+1][j+1].x,points[i+1][j+1].y,points[i+1][j+1].z);
				glVertex3f(points[i+1][j].x,points[i+1][j].y,points[i+1][j].z);
                //lower hemisphere
                glVertex3f(points[i][j].x,points[i][j].y,-points[i][j].z);
				glVertex3f(points[i][j+1].x,points[i][j+1].y,-points[i][j+1].z);
				glVertex3f(points[i+1][j+1].x,points[i+1][j+1].y,-points[i+1][j+1].z);
				glVertex3f(points[i+1][j].x,points[i+1][j].y,-points[i+1][j].z);
			}glEnd();
		}
	}
}

void drawCylinder(double radius,double height,int segments)
{
	struct PT points[100];
	int i;
	double shade;

	// glRotatef(angle,0,0,1);
	

	//generate points
	for(i=0;i<=segments;i++)
	{
		points[i].x=radius*cos(((double)i/(double)segments)*2*pi);
		points[i].y=radius*sin(((double)i/(double)segments)*2*pi);
	}
	//draw quads using generated points
	for(i=0;i<segments;i++)
	{
		//create shading effect
		if(i<segments/2)shade=2*(double)i/(double)segments;
		else shade=2*(1.0-(double)i/(double)segments);
		
		glColor3f(shade,shade,shade);

		glBegin(GL_QUADS);{
			glVertex3f(points[i].x,points[i].y,0);
			glVertex3f(points[i].x,points[i].y,height);
			glVertex3f(points[i+1].x,points[i+1].y,height);
			glVertex3f(points[i+1].x,points[i+1].y,0);
		}glEnd();
	}
}


void drawSS()
{
    glColor3f(1,0,0);
    drawSquare(20);

    glRotatef(angleTurn,0,0,1);
    glTranslatef(110,0,0);
    glRotatef(2*angleTurn,0,0,1);
    glColor3f(0,1,0);
    drawSquare(15);

    glPushMatrix();
    {
        glRotatef(angleTurn,0,0,1);
        glTranslatef(60,0,0);
        glRotatef(2*angleTurn,0,0,1);
        glColor3f(0,0,1);
        drawSquare(10);
    }
    glPopMatrix();

    glRotatef(3*angleTurn,0,0,1);
    glTranslatef(40,0,0);
    glRotatef(4*angleTurn,0,0,1);
    glColor3f(1,1,0);
    drawSquare(5);
}

double distanceTrav;

void drawLookLine()
{	

	 glPushMatrix();
	 {
		glColor3f(1,0,0);
		glBegin(GL_LINES);{
			glVertex3f(0,0,0);
			glVertex3f(pos.x,pos.y,10);
		}
		glEnd();
	 }
	 glPopMatrix();
}

void moveForward()
{
	angleFwd += 2;
	distanceTrav = 2 * pi * wheelR * (double)(2)/(double)(360);
	pos.x -= cos(angleTurn*pi/(double)180) * distanceTrav;
	pos.y -= sin(angleTurn*pi/(double)180) * distanceTrav;
}

void moveBackward()
{
	angleFwd -= 2;
	distanceTrav = 2 * pi * wheelR * (double)(-2)/(double)(360);
	pos.x -= cos(angleTurn*pi/(double)180) * distanceTrav;
	pos.y -= sin(angleTurn*pi/(double)180) * distanceTrav;
}

double max_(double a, double b)
{
	if(a>b)return a;
	else return b;
}

double min_(double a, double b)
{
	if(a<b)return a;
	else return b;
}

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

		case '1':
			drawgrid=1-drawgrid;
			break;

		case 'w':
			// pos.x -= 3;
			moveForward();
			break;
		case 's':
			moveBackward();
			break;
		case 'a':
			angleTurn += 1.5;
			break;
		case 'c':
			wheelR = max_(wheelR-1,8);
			break;
		case 'x':
			wheelR = min_(wheelR+1,15);
			break;
		case 'd':
			angleTurn -= 1.5;
		default:
			break;
	}
}


void specialKeyListener(int key, int x,int y){
	switch(key){
		case GLUT_KEY_DOWN:		//down arrow key
			cameraHeight -= 3.0;
			break;
		case GLUT_KEY_UP:		// up arrow key
			cameraHeight += 3.0;
			break;

		case GLUT_KEY_RIGHT:
			cameraAngle += 0.03;
			break;
		case GLUT_KEY_LEFT:
			cameraAngle -= 0.03;
			break;

		case GLUT_KEY_PAGE_UP:
			break;
		case GLUT_KEY_PAGE_DOWN:
			break;

		case GLUT_KEY_INSERT:
			break;

		case GLUT_KEY_HOME:
			break;
		case GLUT_KEY_END:
			break;

		default:
			break;
	}
}


void mouseListener(int button, int state, int x, int y){	//x, y is the x-y of the screen (2D)
	switch(button){
		case GLUT_LEFT_BUTTON:
			if(state == GLUT_DOWN){		// 2 times?? in ONE click? -- solution is checking DOWN or UP
				drawaxes=1-drawaxes;
			}
			break;

		case GLUT_RIGHT_BUTTON:
			//........
			break;

		case GLUT_MIDDLE_BUTTON:
			//........
			break;

		default:
			break;
	}
}



void drawWheel(int whichOne,int draw)
{
	glPushMatrix();
	{
		
		glTranslatef(0,0,wheelR);
		glTranslatef(pos.x,pos.y,pos.z);
		glColor3f(1,1,1);
		if(draw == 1) drawRectangleWheelUp3(20,20,wheelR+3);
		if(whichOne == 1) drawRectangleWheelUp1(20,20,wheelR);
		else if(whichOne == 2) drawRectangleWheelUp2(20,20,wheelR);
		glRotatef(90,1,0,0);

		glRotatef(angleTurn,0,1,0);
			
		glRotatef(angleFwd,0,0,1);
	
		glPushMatrix();
		{

			drawCylinder(wheelR,wheelH/2,40);
			glTranslatef(0,0,-wheelH/2);
			drawCylinder(wheelR,wheelH/2,40);
			glTranslatef(0,0,wheelH/2);
			// rectangles inside wheel
			glColor3f(1,1,1);
			// // drawSquare(30);
			// glTranslatef(0,0,5);
			glRotatef(90,0,1,0);
			drawRectangle(wheelH/2,wheelR,0);

			glRotatef(90,1,0,0);
			drawRectangle(wheelH/2,wheelR,0);
		}
		glPopMatrix();
	}

	glPopMatrix();
}

void display(){

	//clear the display
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glClearColor(0,0,0,0);	//color black
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	/********************
	/ set-up camera here
	********************/
	//load the correct matrix -- MODEL-VIEW matrix
	glMatrixMode(GL_MODELVIEW);

	//initialize the matrix
	glLoadIdentity();

	//now give three info
	//1. where is the camera (viewer)?
	//2. where is the camera looking?
	//3. Which direction is the camera's UP direction?

	//gluLookAt(100,100,100,	0,0,0,	0,0,1);
	double cameraDistance = 200;
	gluLookAt(cameraDistance*cos(cameraAngle), cameraDistance*sin(cameraAngle), cameraHeight,		0,0,0,		0,0,1);
	// gluLookAt(0,0,200,	0,0,0,	0,1,0);


	//again select MODEL-VIEW
	glMatrixMode(GL_MODELVIEW);


	/****************************
	/ Add your objects from here
	****************************/
	//add objects

	drawAxes();
	drawGrid();



	glPushMatrix();
	{
		drawWheel(1,1);
	}
	glPopMatrix();

	glPushMatrix();
	{
		glTranslatef(40,0,0);
		drawWheel(1,0);
	}
	glPopMatrix();

	glPushMatrix();
	{
		glTranslatef(0,40,0);
		drawWheel(2,0);
	}
	glPopMatrix();

	glPushMatrix();
	{
		glTranslatef(40,40,0);
		drawWheel(2,0);
	}
	glPopMatrix();

	// drawLookLine();

	// glPushMatrix();
	// {
	// 	drawRectangle(40,60,30);
	// }
	// glPopMatrix();



	//ADD this line in the end --- if you use double buffer (i.e. GL_DOUBLE)
	glutSwapBuffers();
}


void animate(){
	// angle+=0.05;
	//codes for any changes in Models, Camera
	glutPostRedisplay();
}

void init(){
	//codes for initialization
	drawgrid=1;
	drawaxes=0;
	cameraHeight=100.0;
	cameraAngle=1.0;
	angleTurn=0;
	angleFwd=0;

	//clear the screen
	glClearColor(0,0,0,0);

	/************************
	/ set-up projection here
	************************/
	//load the PROJECTION matrix
	glMatrixMode(GL_PROJECTION);

	//initialize the matrix
	glLoadIdentity();

	//give PERSPECTIVE parameters
	gluPerspective(60,	1,	1,	1000.0);
	//field of view in the Y (vertically)
	//aspect ratio that determines the field of view in the X direction (horizontally)
	//near distance
	//far distance
}

int main(int argc, char **argv){
	glutInit(&argc,argv);
	glutInitWindowSize(500, 500);
	glutInitWindowPosition(0, 0);
	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGB);	//Depth, Double buffer, RGB color

	glutCreateWindow("My OpenGL Program");

	init();

	glEnable(GL_DEPTH_TEST);	//enable Depth Testing

	glutDisplayFunc(display);	//display callback function
	glutIdleFunc(animate);		//what you want to do in the idle time (when no drawing is occuring)

	glutKeyboardFunc(keyboardListener);
	glutSpecialFunc(specialKeyListener);
	glutMouseFunc(mouseListener);

	glutMainLoop();		//The main loop of OpenGL

	return 0;
}