// OpenGL program that draws simple cart consisting of two red wheels 
// positioned at the ends of a green axis.
// The program uses hierarchical display lists to model the cart.
//
// File: circ.cpp
// Date: 2/16/2001

#include<iostream.h>
#include<GL/glut.h>
#include <math.h>
#include <stdlib.h>

// display lists identifiers
#define WHEEL 1
#define CART 2

// modeling constants
#define NUM_SLICES       24
#define WHEEL_RAD        20.0
#define TH_FRONT         20.0
#define TH_BACK          10.0
#define HALF_AXIS_LENGTH 75.0

//prototypes
void myinit();                      // OpenGL init
void display();                     // display callback
void myreshape(GLsizei, GLsizei);   // reshape callback 
void drawUnitCircle(int num_slices);// approximate unit circle 
void defineParts(void);             // defines the display lists
 
/****************/
/***** MAIN *****/
/****************/
int main(int argc, char **argv)
{
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
	glutInitWindowSize(500,500);
	glutInitWindowPosition(0,0);
	glutCreateWindow("stationary cart");
	
	myinit();
        glutReshapeFunc(myreshape);
	glutDisplayFunc(display);
	glutMainLoop();

	return 0;
}
/********************************/
/***** FUNCTION DEFINITIONS *****/
/********************************/

/*****************************************************************/
// OpenGL init
/*****************************************************************/
void myinit()
{
	glClearColor(1.0,1.0,1.0,0.0);  // white

   	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(-225.0, 225.0, -225, 225.0); // origin at center of 500x500 clip window
	glMatrixMode(GL_MODELVIEW);

	defineParts();
		
}
/*****************************************************************/
// Approximates the unit circle with a polyline going through 
// num_slices points
/*****************************************************************/
void drawUnitCircle(int num_slices)
{ 
	double thetaincr=2*(double)(22.0/7)/num_slices; // the angle per sector
	double th=0.0;  // angle used to generate      // the angle used to generate the points                          
	 
	// approximate unit circle with this
	glBegin(GL_LINE_LOOP);
	   for (int i=0; i<num_slices; i++) {
	       glVertex2f(cos(th), sin(th));
               th += thetaincr;
	   }
        glEnd();
}
/*****************************************************************/
// Models the  2D cart by a hierarchical display list CART. 
// The tree model is as follows
//                axis
//              /      \
//             /T1.R1    \T2.R2
//           WHEEL       WHEEL
//
// where
// WHEEL is a component defined in a display list
// T1.R1 denotes the composition of a rotation, R1, followed by a 
// transpation T1 
/*****************************************************************/     
void defineParts(void)
{
// a red wheel of radius WHEEL_RAD  
//
// wheel frame is righthanded:
//    origin is the center of the circle
//    axis coinside with the unit cross spikes as given below	
glNewList(WHEEL,GL_COMPILE);  // begin WHEEL
     
   	glPushMatrix();
	glPushAttrib(GL_COLOR);

	glColor3f(1.0,0.0,0.0);  
	glScalef(WHEEL_RAD,WHEEL_RAD,1.0);

	glBegin(GL_LINES);        // unit cross
	   glVertex2f( -1.0, 0.0);
	   glVertex2f(1.0, 0.0);
	   glVertex2f( 0.0, -1.0);
	   glVertex2f( 0.0, 1.0);
	glEnd();
        
	drawUnitCircle(NUM_SLICES); // unit circle

	glPopAttrib();
	glPopMatrix();
glEndList();                    // end WHEEL

// a cart consisting of two wheels, front wheel and back wheel are
// rotated differently. The wheels are positioned at the ends of a green axis
// of length 2*HALF_AXIS_LENGTH 
//
// cart frame is righthanded: 
//     origin is at middle point of green axis
//     x-coord axis is the green axis
glNewList(CART,GL_COMPILE);     // begin CART
        glPushMatrix();
	glPushAttrib(GL_COLOR);
        // draw axis in green
	glColor3f(0.0,1.0,0.0);
	glBegin(GL_LINES);
	  glVertex2f(-HALF_AXIS_LENGTH,0.0);
	  glVertex2f(HALF_AXIS_LENGTH,0.0);
        glEnd();

        glPushMatrix();
        glTranslatef(-HALF_AXIS_LENGTH,0.0, 0.0); // position front wheel at axis, T1
        glRotatef(TH_FRONT,0.0,0.0,1.0);          // rotation for front WHEEL, R1 
        glCallList(WHEEL);                        // draw wheel 
    
        glPopMatrix();
        glTranslatef(HALF_AXIS_LENGTH,0.0, 0.0);  // position back wheel at axis, T2 
        glRotatef(TH_BACK, 0.0,0.0,1.0);          // rotation for back WHEEL, R2 
        glCallList(WHEEL);                        // draw wheel
    
        glPopAttrib();
        glPopMatrix();
glEndList();
}
/*****************************************************************/    
// display callback
/*****************************************************************/
void display()
{
       glClear(GL_COLOR_BUFFER_BIT);
       glCallList(CART);                          // draw cart at center of world frame 
       glFlush();
}
/*****************************************************************/
// window events (reshape) callback.
/*****************************************************************/
void myreshape(GLsizei w, GLsizei h)
{
	// adjust clipping rectrngle
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(-(GLdouble)w/2, (GLdouble)w/2, -(GLdouble)h/2, (GLdouble)h/2);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	// adjust viewport (to preserve the original aspect ratio),
	// and clear.
	glViewport(0, 0, w, h); 
   	glClearColor(1.0,1.0,1.0,0.0);
	glClear(GL_COLOR_BUFFER_BIT);
        glFlush();
	
}