Bike Code

/**************************************
* Beginning of the header file "bike.h"
***************************************/
#include<GL/glut.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#define PI 3.14159
#define WIN_WIDTH 1920
#define WIN_HEIGHT 1080
#define BIKE_LENGTH 3.3f
#define ROD_RADIUS 0.05f
#define GAS_TANK 0.3f
#define NUM_SPOKES 5
#define SPOKE_ANGLE 72
#define RADIUS_WHEEL 1.0f
#define TUBE_WIDTH 0.20f
#define RIGHT_ROD 2.35f
#define RIGHT_ANGLE 33.0f
#define MIDDLE_ROD 1.8f
#define MIDDLE_ANGLE 125.0f
#define BACK_CONNECTOR 0.5f
#define LEFT_ANGLE 50.0f
#define WHEEL_OFFSET 0.11f
#define WHEEL_LEN 0.8f

#define TOP_LEN 1.0f
#define FRONT_ROD 2.5f
#define CRANK_ROD 1.9f
#define CRANK_RODS 2.5f
#define CRANK_ANGLE 0.0f
#define HANDLE_ROD 1.2f
#define FRONT_INCLINE 38.0f
#define HANDLE_LIMIT 30.0f
#define INC_STEERING 2.0f
#define INC_SPEED 0.05f
/*****************************************
* All the Global Variables are Here
****************************************/
/*****************************************
* Bike - related variables
******************************************/
GLfloat pedalAngle, speed, steering;
/*******************************
* User view related variables
********************************/
GLfloat camx,camy,camz;
GLfloat anglex,angley,anglez;
/****************************
* Mouse related variables

****************************/
int prevx,prevy;
GLenum Mouse;
/**************************
* Bike position related
* variables
***************************/
GLfloat xpos,zpos,direction;
void welcome_window(); void
operations_window(); void ZCylinder(GLfloat
radius,GLfloat length); void
XCylinder(GLfloat radius,GLfloat length);
void drawFrame(void); void gear( GLfloat
inner_radius, GLfloat outer_radius, GLfloat
width,GLint teeth, GLfloat tooth_depth ); void
drawChain(void); void drawPedals(void); void
drawTyre(void); void drawSeat(void); void
init(void); void reset(void); void display_bike(void);
void idle(void); void updateScene(void); void
landmarks(void); void special(int key,int x,int y);
void keyboard(unsigned char key,int x,int y);
void mouse(int button,int state,int x,int y);
void motion(int x,int y); GLfloat
Abs(GLfloat);
GLfloat degrees(GLfloat);
GLfloat radians(GLfloat);
GLfloat angleSum(GLfloat, GLfloat);
/*************************************
* End of the header file
*************************************/
/**************************************
* Start of the source file "bike.c"
**************************************/
//#include "bike.h"
/******************************************
* A
* 1 ========== 2
* /\ | B
* / \ /5
* E/ \D /
* / \ /C
* / \/
* 3 ==========/ 4
* F
* 1 = 212,82
* 2 = 368,82
* 5 = 369,94
* 3 = 112,220
* 4 = 249,232
*
* 214 = 73 //angle between 2,1 & 4
* 124 = 55
* 142 = 52
* 143 = 73
* 134 = 50
* 431 = 57
****************************************/
void ZCylinder(GLfloat radius,GLfloat length)
GLUquadricObj *cylinder;
cylinder=gluNewQuadric(); glPushMatrix();
glTranslatef(0.0f,0.0f,0.0f);
gluCylinder(cylinder,radius,radius,length,15,5);
glPopMatrix();
void XCylinder(GLfloat radius,GLfloat length)
{ glPushMatrix();
glRotatef(90.0f,0.0f,1.0f,0.0f);
ZCylinder(radius,length);
glPopMatrix();
// called by idle() void
updateScene()
GLfloat xDelta, zDelta; //Distance

GLfloat rotation;
GLfloat sin_steering, cos_steering;
// if the tricycle is not moving then do nothing
if (-INC_SPEED < speed && speed < INC_SPEED) return; //"speed<INC_SPEED" because if again
accelerated, the bike stops moving if we put speed>INC_SPEED since speed value crosses INC_SPEED
if(speed < 0.0f)
pedalAngle = speed = 0.0f;
// otherwise, calculate the new position of the tricycle
// and the amount that each wheel has rotated.
// The tricycle has moved "speed*(time elapsed)".
// We assume that "(time elapsed)=1".
xDelta = speed*cos(radians(direction + steering)); //To find out the new position of the bike once it starts
moving
zDelta = speed*sin(radians(direction + steering)); xpos += xDelta; //Initialise
this calculated new position to the variable xpos & zpos zpos -= zDelta;
pedalAngle = degrees(angleSum(radians(pedalAngle), speed/RADIUS_WHEEL)); //Pedal rotates as bike

moves but this effect has been neutralised in the program
// we'll be using sin(steering) and cos(steering) more than once
// so calculate the values one time for efficiency
sin_steering = sin(radians(steering)); //Angle calculated for rotation of our bike towards the direction of
handle rotation cos_steering = cos(radians(steering));
// see the assignment 3 "Hint"
rotation = atan2(speed * sin_steering, BIKE_LENGTH + speed * cos_steering); //atan2(); used mostly to convert
from rectangular (x,y) to polar (r,0) direction = degrees(angleSum(radians(direction),rotation)); }
// angleSum(a,b) = (a+b) MOD 2*PI
// a and b are two angles (radians)
// both between 0 and 2*PI
GLfloat angleSum(GLfloat a, GLfloat b)
{ a +=
b;
if (a < 0) return a+2*PI; //If returned angle is towards left and lesser than its threshold value,
increment its value to zero & do nothing
else if (a > 2*PI) return a-2*PI; //If returned angle is towards right and greater than its threshold
value, decrement its value to zero & do nothing
else return a; //If nothing, return the radians equivalent of angle 'a' }
/************************************************
* Draw the metal frame of the bike and also
* draw the seat and the back wheel with
* this.
* All these parts are always together in the
* same plane.They never move out ot the
* PLANE!
************************************************/ void
drawFrame()
{ glColor3f(1.0f,0.0f,0.0
f);
/********************************
* First draw the all the items * at the center of the
frame.
* Draw the bigger gear,the small

* cylinder acting as the socket
* for the foot rest.Also DON'T
* forget to draw the two
* connecting cemtral rods
*********************************/
glPushMatrix();
/******************************
* Allow me to draw the BIGGER
* gear and the socket cylinder
*******************************/
glPushMatrix();
/***************************
* Let the gear have the
* green color
***************************/
glColor3f(0.0f,1.0f,0.0f);
/**************************
* The gear should be
* outside the frame !!!
* This is the bigger
* GEAR
***************************/
glPushMatrix();
glTranslatef(0.0f,0.0f,0.06f); glRotatef(-
2*pedalAngle,0.0f,0.0f,1.0f);
gear(0.08f,0.3f,0.03f,30,0.03f);
glPopMatrix();
/***************************
* Restore the color of the

* frame
****************************/
glTranslatef(0.0f,0.0f,-0.2f);
ZCylinder(0.08f,0.32f); glPopMatrix();
/*****************************
* Lets first draw the
* rightmost rod of the frame
*******************************/
glRotatef(RIGHT_ANGLE,0.0f,0.0f,1.0f);
XCylinder(ROD_RADIUS,RIGHT_ROD);
/*******************************
* Now draw the centre rod of
* the frame which also supports
* the seat
*********************************/ glRotatef(MIDDLE_ANGLE-
RIGHT_ANGLE,0.0f,0.0f,1.0f);
XCylinder(ROD_RADIUS,MIDDLE_ROD);
/********************************
* We have drawn the support.So
* let's draw the seat with a
* new color
*********************************/
glTranslatef(MIDDLE_ROD,0.0f,0.0f);
glRotatef(-MIDDLE_ANGLE,0.0f,0.0f,1.0f);
glScalef(0.3f,ROD_RADIUS,0.25f);
drawSeat(); /**********************
* Restore the color !
************************/
glPopMatrix();
/*********************************
* Draw the horizontal part of
* the frame.
*********************************/
/*********************************
* Draw the main single rod
* connecting the center of the
* frame to the back wheel of the
* bike
**********************************/
glPushMatrix(); glRotatef(-
180.0f,0.0f,1.0f,0.0f);
XCylinder(ROD_RADIUS,BACK_CONNECTOR);
/***********************************
* Draw the two rods on the either
* side of the front wheel
* These rods are part of the
* horizontal part of the bike
************************************/
glPushMatrix();
glTranslatef(0.5f,0.0f,WHEEL_OFFSET);
XCylinder(ROD_RADIUS,RADIUS_WHEEL+TUBE_WIDTH);
glPopMatrix(); glPushMatrix();
glTranslatef(0.5f,0.0f,-WHEEL_OFFSET);
XCylinder(ROD_RADIUS,RADIUS_WHEEL+TUBE_WIDTH);
glPopMatrix();
glPopMatrix();
/************************************
* Draw the leftmost rods(back part) of the
* frame of the bike
*************************************/
glPushMatrix();
glTranslatef(-(BACK_CONNECTOR+RADIUS_WHEEL+TUBE_WIDTH),0.0f,0.0f);
/********************************
* Transalted to the back wheel * position.Why not
draw the back
* wheel and also the gear ?
**********************************/
glPushMatrix(); glRotatef(-
2*pedalAngle,0.0f,0.0f,1.0f);
drawTyre(); glColor3f(0.0f,1.0f,0.0f);
gear(0.03f,0.15f,0.03f,20,0.03f);
glColor3f(1.0f,0.0f,0.0f); glPopMatrix();
glRotatef(LEFT_ANGLE,0.0f,0.0f,1.0f);
/************************************
* Draw the two rods on the either
* side of the wheel connecting the
* backwheel and topmost horizontal
* part of the wheel
*************************************/
glPushMatrix(); glTranslatef(0.0f,0.0f,-
WHEEL_OFFSET);
XCylinder(ROD_RADIUS,WHEEL_LEN);
glTranslatef(0.0f,0.0f,WHEEL_OFFSET);
XCylinder(ROD_RADIUS,WHEEL_LEN);
glPopMatrix();
/*****************************
* Draw the single rod of the
* same setup
******************************/
glTranslatef(WHEEL_LEN,0.0f,0.0f);
XCylinder(ROD_RADIUS,CRANK_ROD-1.0); //It is the rod which connects the handle bar and the
connector rods of the front wheel
//Draw Main Supporting Rod
glTranslatef(CRANK_ROD,0.0f,0.0f); glRotatef(-
LEFT_ANGLE,0.0f,0.0f,1.0f);
XCylinder(0.0000000001,TOP_LEN); //Its thickness has been reduced since it acts as a supporting rod,
hence it's not necessary to display it
/*******************************
* Now instead of again traversing

* all the way back and again * forward.WHY
NOT DRAW THE
* HANDLE FROM HERE ITSELF?
********************************/
//Draw The Gas Tank
glPushMatrix();
glTranslatef(-0.6,-0.6f,0.0f);
XCylinder(GAS_TANK,1.0f);
glPopMatrix();
//Draw the head light
glPushMatrix();
glTranslatef(0.6,0.5f,0.0f);
glPopMatrix();
//Draw The Exhaust
glPushMatrix();
XCylinder(ROD_RADIUS+0.1f,1.5f); //Right lower
glColor3f(0.5f,0.5f,0.5f); glTranslatef(-3.2,-
2.1f,0.3f); glRotatef(120.0,0.0f,0.0f,1.0f);
XCylinder(ROD_RADIUS+0.1f,0.5f); //Right upper
glColor3f(0.5f,0.5f,0.5f); glTranslatef(-3.2,-2.1f,-
0.3f);
XCylinder(ROD_RADIUS+0.1f,1.5f); //Left lower
glColor3f(0.5f,0.5f,0.5f); glTranslatef(-3.2,-2.1f,-0.3f);
glRotatef(120.0,0.0f,0.0f,1.0f);
XCylinder(ROD_RADIUS+0.1f,0.5f); //Left upper
glPopMatrix();
//Draw The Right Doom glPushMatrix();
glColor3f(0.5f,0.5f,0.5f); glTranslatef(0.4,-0.8f,0.2f);
glRotatef(LEFT_ANGLE,0.0f,0.0f,1.0f);
XCylinder(GAS_TANK,1.0f); //Right upper
glTranslatef(0.2,-0.8f,0.2f); glRotatef(LEFT_ANGLE-
50.0,0.0f,0.0f,1.0f); XCylinder(GAS_TANK,1.0f);
//Right lower glPopMatrix();
//Draw The Left Doom glPushMatrix();
glColor3f(0.5f,0.5f,0.5f); glTranslatef(0.4,-0.8f,-
0.2f); glRotatef(LEFT_ANGLE,0.0f,0.0f,1.0f);
XCylinder(GAS_TANK,1.0f); //Left upper
glTranslatef(0.2,-0.8f,-0.2f);
glRotatef(LEFT_ANGLE-50.0,0.0f,0.0f,1.0f);
XCylinder(GAS_TANK,1.0f); //Left lower
glPopMatrix();
//Draw The Engine
glPushMatrix();
glColor3f(0.1,0.1,0.1); glTranslatef(-
0.4f,-1.2f,0.0f);
glPopMatrix();
/*****************************
* Now draw the handle and
* small support rod which
* is incorporated in the * frame itself. * Set
y-axis at the required
* incline.
******************************/
glTranslatef(TOP_LEN,0.0f,0.0f); //Supporting rod position
glRotatef(-FRONT_INCLINE,0.0f,0.0f,1.0f);
/******************************
* I Hope the handle can rotate
* about its mean position
*******************************/
glPushMatrix();
glRotatef(-steering/2.0,1.0f,0.0f,0.0f);
/******************************
* Roll back to the height of
* the handle to draw it
*******************************/
glTranslatef(-0.3f,0.0f,0.0f);
/********************************
* We cannot use the incline
* the incline to draw the
* horizontal part of the rod
********************************/
glPushMatrix();
glRotatef(FRONT_INCLINE,0.0f,0.0f,1.0f);
glPushMatrix(); glTranslatef(-
0.6f,0.5f,-HANDLE_ROD/2);
ZCylinder(ROD_RADIUS,HANDLE_ROD);
glPopMatrix();
glPushMatrix(); glColor3f(1.0f,1.0f,0.0f);
glTranslatef(-0.6f,0.5f,-HANDLE_ROD/2); //Handle
ZCylinder(0.07f,HANDLE_ROD/4); //Rods
glTranslatef(0.0f,0.0f,HANDLE_ROD*3/4); //Are
ZCylinder(0.07f,HANDLE_ROD/4); //Drawn
glColor3f(1.0f,0.0f,0.0f); //Here
glPopMatrix(); glPopMatrix();
/*********************************
* Using this incline now draw * the
handle.Maybe use this again
* to draw the wheel.

**********************************/
glPushMatrix();
/****************************
* Draw the main big rod

****************************/
glTranslatef(-0.75,0.0,0.0);
XCylinder(ROD_RADIUS,FRONT_ROD);
/******************************
* Why not draw the two rods and
* the WHEEL? * Yes!So,first go to the
* end of the main rod.
*******************************/
glTranslatef(CRANK_ROD,0.0f,0.0f); //Position set to the end of the main big connector rod in the
front to draw the front connector rods at that position glRotatef(CRANK_ANGLE,0.0f,0.0f,1.0f);
/*******************************
* Draw the two rods connecting
* the handle and the front
* wheel.
* The two rods are at a incline
* to the connector.
********************************/
glPushMatrix();
glTranslatef(0.0f,0.0f,WHEEL_OFFSET-0.35);
XCylinder(ROD_RADIUS,CRANK_RODS);
glTranslatef(0.0f,0.0f,-WHEEL_OFFSET+0.35);
XCylinder(ROD_RADIUS,CRANK_RODS);
glPopMatrix();
/********************************
* Why not draw the wheel.

* The FRONT wheel to be precise
*********************************/
glTranslatef(CRANK_RODS,0.0f,0.0f);
glRotatef(-2*pedalAngle,0.0f,0.0f,1.0f);
drawTyre(); glPopMatrix(); glPopMatrix();
/* End of the rotation of the handle effect */
glPopMatrix();
//Draw the bulb for the headlight
glPushMatrix();
glColor3f(1.0,1.0,0.0);
glRotatef(360.0,1.0,0.0,0.0);
glTranslatef(1.0,2.6,0.0);
glutSolidSphere(0.2,160.0,180.0);
glPopMatrix();
//Draw the human on the bike //Draw
the head glPushMatrix();
glRotatef(180.0,1.0,0.0,0.0);
glutSolidSphere(0.4,160.0,180.0);
glPopMatrix();
//Draw the eyes glPushMatrix(); glRotatef(-
steering/2.0,1.0f,0.0f,0.0f); glColor3f(1.0f,1.0f,1.0f);
glRotatef(180.0,1.0,0.0,0.0); glTranslatef(-0.6,-3.6f,-
0.15f); glutSolidSphere(0.05,160.0,180.0); //Right
white eye glPopMatrix();
glPushMatrix();
glColor3f(1.0f,1.0f,1.0f); glRotatef(180.0,1.0,0.0,0.0);
glutSolidSphere(0.05,160.0,180.0); //Left white eye
glPopMatrix();
glPushMatrix();
glRotatef(180.0,1.0,0.0,0.0); glTranslatef(-0.6,-
3.6f,-0.15f); glutSolidSphere(0.025,160.0,180.0);
//Right black eye lid glPopMatrix();
glPushMatrix(); glRotatef(-steering/2.0,1.0f,0.0f,0.0f);
glColor3f(0.0f,0.0f,0.0f); glRotatef(180.0,1.0,0.0,0.0);
glutSolidSphere(0.025,160.0,180.0); //Left black eye lid
glPopMatrix();
//Draw the nose glPushMatrix();
glColor3f(0.5f,0.3f,0.0f); glRotatef(-
270.0,-1.0,0.0,0.0); glTranslatef(-
0.6,0.0f,3.4f);
glutSolidCone(0.1,0.2,50.0,50.0);
glPopMatrix();
//Draw the mouth glPushMatrix();
glRotatef(-steering/2.0,1.0f,0.0f,0.0f); glColor3f(1.0f,0.0f,1.0f); //It
is made pink to indicate the rider's lips glRotatef(90.0,0.0,1.0,0.0);
glTranslatef(-0.1,3.3f,-0.6f);
XCylinder(ROD_RADIUS,0.25f);
glPopMatrix();
//Draw the upper part of the body
glPushMatrix();
glRotatef(80.0,0.0,0.0,1.0);
XCylinder(GAS_TANK+0.15,1.5);
glPopMatrix();
//Draw the hands glPushMatrix();
glRotatef(150.0,0.0,0.0,1.0);
glTranslatef(1.8,-2.0,-0.6);
XCylinder(GAS_TANK-0.1,1.0); //Left upper arm
glPopMatrix();
glPushMatrix();
glRotatef(150.0,0.0,0.0,1.0); glTranslatef(1.8,-
2.0,0.6);
XCylinder(GAS_TANK-0.1,1.0); //Right upper arm
glPopMatrix();
glPushMatrix();
glRotatef(180.0,0.0,0.0,1.0); glTranslatef(-0.3,-2.6,-
0.6);
XCylinder(GAS_TANK-0.1,1.0); //Left lower arm
glPopMatrix();
glPushMatrix();
glRotatef(180.0,0.0,0.0,1.0); glTranslatef(-0.3,-
2.6,0.6);
XCylinder(GAS_TANK-0.1,1.3); //Right lower arm
glPopMatrix();
//Draw the legs
glPushMatrix();
glRotatef(180.0,0.0,0.0,1.0);
glTranslatef(0.3,-1.6,0.6);
XCylinder(GAS_TANK-0.1,1.5); //Right upper leg
glPopMatrix();
glPushMatrix();
glRotatef(180.0,0.0,0.0,1.0);
glTranslatef(0.3,-1.6,-0.6);
XCylinder(GAS_TANK-0.1,1.5); //Left upper leg glPopMatrix();
glPushMatrix();
glRotatef(100.0,0.0,0.0,1.0);
glTranslatef(0.0,0.0,-0.6);
XCylinder(GAS_TANK-0.1,1.7); //Left lower leg
glPopMatrix();
glPushMatrix();
glRotatef(100.0,0.0,0.0,1.0);
XCylinder(GAS_TANK-0.1,1.7); //Right lower leg
glPopMatrix();
/*
* Draw a gear wheel. You'll probably want to call

this function when
* building a display list since we do a lot of trig here.
* Input: inner_radius - radius of hole at center
* outer_radius - radius at center of teeth
* width - width of gear
* teeth - number of teeth
* tooth_depth - depth of tooth
*/
void gear( GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
GLint teeth, GLfloat tooth_depth )
GLint i;
GLfloat r0, r1, r2;
GLfloat angle, da; GLfloat
u, v, len; const double pi =
3.14159264;
r0 = inner_radius; r1 =
outer_radius - tooth_depth/2.0; r2
= outer_radius + tooth_depth/2.0;
da = 2.0*pi / teeth / 4.0;
glShadeModel( GL_FLAT ); //Select flat(matt finished) or smooth shading
glNormal3f( 0.0, 0.0, 1.0 ); //For flat shading,glNormal3f() has to be called for each face
/* draw front face */ glBegin( GL_QUAD_STRIP ); //For indicating
the sharpness of gear teeth for (i=0;i<=teeth;i++) { angle = i * 2.0*pi / teeth;
glVertex3f( r0*cos(angle), r0*sin(angle), width*0.5 );
glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), width*0.5 );
glEnd();
/* draw front sides of teeth */
glBegin( GL_QUADS );
da = 2.0*pi / teeth / 4.0;
for (i=0;i<teeth;i++)
{ angle = i * 2.0*pi / teeth;
glVertex3f( r2*cos(angle+da), r2*sin(angle+da), width*0.5 );
glEnd();
glNormal3f( 0.0, 0.0, -1.0 );
/* draw back face */
glBegin( GL_QUAD_STRIP );
for (i=0;i<=teeth;i++) { angle = i * 2.0*pi / teeth; glVertex3f(
r1*cos(angle), r1*sin(angle), -width*0.5 );
glVertex3f( r0*cos(angle), r0*sin(angle), -width*0.5 );
glVertex3f( r1*cos(angle+3*da), r1*sin(angle+3*da), -width*0.5 );
glEnd(); /
* draw back
sides of teeth
*/
glBegin( GL
_QUADS );
da = 2.0*pi / teeth / 4.0;
glVertex3f( r2*cos(angle+da), r2*sin(angle+da), -width*0.5 );
glEnd();
/* draw outward faces of teeth */

u = r2*cos(angle+da) - r1*cos(angle); v = r2*sin(angle+da)
- r1*sin(angle); len = sqrt( u*u + v*v ); u /= len; v /=
len; glNormal3f( v, -u, 0.0 );
glVertex3f( r2*cos(angle+da), r2*sin(angle+da), width*0.5 );
glVertex3f( r2*cos(angle+da), r2*sin(angle+da), -width*0.5 );
glNormal3f( cos(angle), sin(angle), 0.0 );
u = r1*cos(angle+3*da) - r2*cos(angle+2*da); v =
r1*sin(angle+3*da) - r2*sin(angle+2*da); glNormal3f( v, -u, 0.0 );
glNormal3f( cos(angle), sin(angle), 0.0 );
glVertex3f( r1*cos(0.0), r1*sin(0.0), width*0.5 );
glVertex3f( r1*cos(0.0), r1*sin(0.0), -width*0.5 );
glEnd();
glShadeModel( GL_SMOOTH );
/* draw inside radius cylinder */
for (i=0;i<=teeth;i++) { angle = i * 2.0*pi / teeth;
glNormal3f( -cos(angle), -sin(angle), 0.0 );
glEnd();
/******************************************
* The chain has been done
* by using the trippled lines strip.
* But all those alternate line strips
* are drawn such that those will sit
* on the teeth only
******************************************/
void drawChain()
GLfloat depth;
static int mode=0;
glEnable(GL_LINE_STIPPLE); mode=(mode+1)%2;
if(mode==0 && speed>0) glLineStipple(1,0x1c47); //Used ASCII value for situating on the teeth
exactly while bike is at rest else if(mode==1 && speed>0) glLineStipple(1,0x00FF); //Used
ASCII value for situating on the teeth exactly while bike is moving
glBegin(GL_LINES);
for(depth=0.06f;depth<=0.12f;depth+=0.01f) {
glVertex3f(-1.6f,0.15f,ROD_RADIUS);
glVertex3f(0.0f,0.3f,depth);
glVertex3f(-1.6f,-0.15f,ROD_RADIUS);
glVertex3f(0.0f,-0.3f,depth);
} glEnd(); glDisable(GL_LINE_STIPPLE); //Enable or disable server-side
GL capabilities
void drawSeat() //Drawn somewhat to similar seat for a single seater
/*********************************
* Draw the top of the seat
**********************************/
glBegin(GL_POLYGON);
glVertex3f(-0.1f, 1.0f, -0.5f);
glVertex3f( 1.0f, 1.0f, -0.3f);
glVertex3f( 1.0f, 1.0f, 0.3f);
glVertex3f(-0.1f, 1.0f, 0.5f);
glVertex3f(-1.0f, 1.0f, -1.0f);
glVertex3f(-0.5f, 1.0f, -1.0f);
glEnd();
/**********************************
* Draw the bottom base part of the
* seat
***********************************/
glBegin(GL_POLYGON);
glVertex3f(-0.1f, -1.0f, -0.5f);
glVertex3f( 1.0f, -1.0f, -0.3f);
glVertex3f( 1.0f, -1.0f, 0.3f);
glVertex3f(-0.1f, -1.0f, 0.5f);
glVertex3f(-0.5f, -1.0f, 1.0f);
glVertex3f(-1.0f, -1.0f, 1.0f);
glVertex3f(-1.0f, -1.0f, -1.0f);
glVertex3f(-0.5f, -1.0f, -1.0f);
glEnd();
/**********************
* Draw the sides!
**********************/
glBegin(GL_QUADS);
glVertex3f(1.0f,1.0f,-0.3f);
glVertex3f(1.0f,1.0f,0.3f); glVertex3f(1.0f,-
1.0f,0.3f); glVertex3f(1.0f,-1.0f,-0.3f);
glVertex3f(1.0f,1.0f,0.3f); glVertex3f(-
0.1f,1.0f,0.5f); glVertex3f(-0.1f,-1.0f,0.5f);
glVertex3f(1.0f,-1.0f,0.3f); glVertex3f(1.0f,1.0f,-
0.3f); glVertex3f(-0.1f,1.0f,-0.5f); glVertex3f(-
0.1f,-1.0f,-0.5f); glVertex3f(1.0f,-1.0f,-0.3f);
glVertex3f(-0.1f,1.0f,0.5f); glVertex3f(-
glVertex3f(-0.1f,-1.0f,0.5f);
glVertex3f(-0.1f,1.0f,-0.5f); glVertex3f(-
0.5f,1.0f,-1.0f); glVertex3f(-0.5f,-1.0f,-1.0f);
glVertex3f(-0.1f,-1.0f,-0.5f);
glVertex3f(-0.5f,1.0f,-1.0f); glVertex3f(-
glVertex3f(-0.5f,-1.0f,-1.0f);
glEnd();
void drawPedals() //Drawn for foot rest
{ glColor3f(0.0f,0.0f,1.0
f);
/***************************
* Lets draw the two pedals
* offset from the center
* of the frame.
****************************/
/*****************************
* First draw the one visible
* to the viewer
*****************************/
glPushMatrix();
/*************************
* Draw the pedal rod
*************************/
glPushMatrix();
glScalef(0.5f,0.1f,0.1f);
glutSolidCube(1.0f); glPopMatrix();
/************************
* Draw the resting pad
************************/ glPushMatrix();
glScalef(0.2f,0.02f,0.3f); glutSolidCube(1.0f);
glPopMatrix();
glPopMatrix();
/*******************************
* Draw the one on the other
* side of the frame
*******************************/
glPushMatrix(); glTranslatef(0.0f,0.0f,-
0.105f); glTranslatef(0.25f,0.0f,0.0f);
/***************************
* Now again draw the pedal
* rod
***************************/
glPushMatrix();
/****************************
* Draw the resting pad of
* the pedal
*****************************/
glPushMatrix();
glPopMatrix();
}
void drawTyre(void)
{ in
t i;
// Draw The Disc
glutSolidTorus(-0.17,0.29,100,100); //
Draw The Rim
glutSolidTorus(-0.05f,-0.75f,100,100);
// Draw The Central Cylinder
// Length of cylinder 0.12f
glPushMatrix();
ZCylinder(0.02f,0.12f); glPopMatrix();
glutSolidTorus(0.02f,0.02f,3,20);
// Draw The Spokes // Note:
Spokes are not made thicker
for(i=0;i<NUM_SPOKES;++i)
glPushMatrix();
glRotatef(i*SPOKE_ANGLE,0.0f,0.0f,1.0f);
glBegin(GL_LINES);
glVertex3f(0.0f,0.02f,0.0f);
glVertex3f(0.0f,0.86f,0.0f); glEnd();
glPopMatrix();
// Draw The Tyre
glutSolidTorus(TUBE_WIDTH,RADIUS_WHEEL,10,30);
void init()
GLfloat mat_specular[]={1.0,1.0,1.0,1.0};
GLfloat mat_shininess[]={100.0};
GLfloat light_directional[]={1.0,1.0,1.0,1.0};
GLfloat light_positional[]={1.0,1.0,1.0,1.0};
GLfloat light_diffuse[]={1.0,1.0,1.0};
reset();
glShadeModel(GL_SMOOTH);
glLightfv(GL_LIGHT0,GL_POSITION,light_directional);
glLightfv(GL_LIGHT0,GL_AMBIENT,light_diffuse);
glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse);
glMaterialfv(GL_FRONT,GL_SHININESS,mat_shininess);
glMaterialfv(GL_FRONT,GL_SPECULAR,mat_specular); glColorMaterial(GL_FRONT,GL_DIFFUSE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_DEPTH_TEST);
void landmarks(void) //Created using a rectangular mesh
GLfloat i;
/************************************
* Draw the ground for the bike
* Looks incomplete with it!Don't
* forget to define the normal
* vectors for the vertices.
* gotta fix this bug!
************************************/
glBegin(GL_LINES); for(i=-100.0f ;
i<100.0f ; i += 1.0f)
glVertex3f(-100.0f,-RADIUS_WHEEL,i);
glVertex3f( 100.0f,-RADIUS_WHEEL,i);
glVertex3f(i,-RADIUS_WHEEL,-100.0f);
glVertex3f(i,-RADIUS_WHEEL,100.0f);
glEnd();
}
void display_bike(void)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_NORMALIZE);
glPushMatrix();
/*******************************
* Prepare the rotations
* and start doing the
* remaining scene
*******************************/
glRotatef(angley,1.0f,0.0f,0.0f);
glRotatef(anglex,0.0f,1.0f,0.0f);
glRotatef(anglez,0.0f,0.0f,1.0f);
/***********************
* Start rendering
* the scene of
* the bike
**********************/
landmarks();
/****************************
* Move the bike.
****************************/
glPushMatrix();
glTranslatef(xpos,0.0f,zpos);
glRotatef(direction,0.0f,1.0f,0.0f);
drawFrame();
drawChain(); glPopMatrix();
glPopMatrix(); glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); gluLookAt(camx,camy,camz,
camx,1.0,0.0,0.0,1.0,1.0);
glutSwapBuffers();
/************************
* Returns the absolute
* value of a given
* float number
************************/
GLfloat Abs(GLfloat a)
{ if(a <
0.0f)
return -a;
else
return a;
/************************
* Returns the value of

* the given angle in
* degrees
************************/
GLfloat degrees(GLfloat a)
{ return
a*180.0f/PI;
/************************
* Returns the value of
* the given angle in
* radians
************************/
GLfloat radians(GLfloat a)
{ return
a*PI/180.0f;
/*************************
* The idle function of
* the program which makes
* the contniuous loop
***************************/
void idle(void)
{ updateScene();
glutPostRedisplay();
}
void special(int key,int x,int y)
{ switch(ke
y)
case GLUT_KEY_UP:
camz -= 0.1f;
break;
case GLUT_KEY_DOWN:
camz += 0.1f;
break;
case GLUT_KEY_LEFT:
camx -= 0.1f;
break;
case GLUT_KEY_RIGHT:
camx += 0.1f;
break;
/*****************************
* Reset The scene
* Bringing the bike
* back to its initial position
*****************************/
void reset()
{ glColor3f(1.0f,1.0f,1.0f);
anglex=angley=anglez=0.0f;
pedalAngle=steering=0.0f;
Mouse=GLUT_UP;
pedalAngle=speed=steering=0.0f;
camx=camy=0.0f;
camz=5.0f; xpos=zpos=0.0f;
direction=0.0f; glPushMatrix();
glRotatef(100.0,0.0,0.0,1.0);
glTranslatef(-1.0,0.0,-0.6);
XCylinder(GAS_TANK-0.1,2.7);
glPopMatrix();
void keyboard(unsigned char key,int x,int y)
GLfloat r=0.0f,g=0.0f;
switch(key)
{ case
'r': case
'R':
reset();
break;
case 's':
case 'S':
glutDisplayFunc(operations_window);
break;
case 'c': case
'C':
glutDisplayFunc(display_bike);
break;
case '1':
if(steering < HANDLE_LIMIT)
steering += INC_STEERING;
break;
case '2':
if(steering > -HANDLE_LIMIT)
steering -= INC_STEERING;
break;
case '+':
speed += INC_SPEED;
break;
case '-':
speed -= INC_SPEED;
break;
case 27:
exit(1);
/********************************
* Where is my Bike?
*********************************/
/*********************************
* When you rotate the handle the
* bike as a whole does not rotate * at once
immediately.
* For each unit of time, the
* handle slowly begins to align * with the rest of the
body of the * bike.
* I Think that the rate at which the
* handle aligns with the body is * dependant on the
speed too!!
* The rate is given by 'delta'
* and the speed is given by 'speed'
************************************/
/***********************
* Check out the error
* conditions ;>
***********************/
pedalAngle += speed;
if(speed < 0.0f) speed =
0.0f; if(pedalAngle < 0.0f)
pedalAngle = 0.0f;
if(pedalAngle >= 360.0f)
pedalAngle -= 360.0f;
/******************
* Go! Display
*******************/
} void mouse(int button,int state,int x,int
y) { switch(button)
case GLUT_LEFT_BUTTON:
if(state==GLUT_DOWN)
Mouse=GLUT_DOWN;
prevx=x;
prevy=y;
if(state==GLUT_UP)
Mouse=GLUT_UP;
break;
case GLUT_RIGHT_BUTTON:
/* DO NOTHING */
break;
void passive(int x,int y) {
/* DO NOTHING */
void motion(int x,int y)
{
if(Mouse==GLUT_DOWN)
{ int deltax,deltay; deltax=prevx-x;
deltay=prevy-y; anglex += 0.5*deltax; angley
+= 0.5*deltay; if(deltax!=0 && deltay!=0)
anglez += 0.5*sqrt(deltax*deltax + deltay*deltay);
if(anglex < 0)
anglex+=360.0;
if(angley < 0)
angley+=360.0;
if(anglez < 0)
anglez += 360.0;
if(anglex > 360.0)
anglex-=360.0; if(angley
> 360.0) angley-=360.0;
if(anglez > 360.0)
anglez-=360.0;
else
Mouse=GLUT_UP;
prevx=x;
prevy=y;
}
void reshape(int w,int h)
{ glViewport(0,0,(GLsizei)w,
(GLsizei)h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0,(GLfloat)w/(GLfloat)h,0.1,100.0);
//Angle,Aspect Ratio,near plane,far plane
glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); gluLookAt(camx,camy,camz,
0.0,0.0,0.0, 0.0,1.0,0.0);
void bitmap_output(float x, float y, float z, char *string)
{ int len,
i;
glRasterPos3f(x,y,z);
len = (int) strlen(string);
for (i = 0; i < len; i++) {
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, string[i]);
void welcome_window()
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glClearColor(0,0,0,0); glColor3f(1.0,1.0,1.0); bitmap_output(-
1.25,1.8,0.50,"VISVESVARAYA TECHNOLOGICAL UNIVERSITY"); bitmap_output(-
0.6,1.6,0.50,"BELGAUM,KARNATAKA"); bitmap_output(-0.3,0.70,0.50,"Project On");

bitmap_output(-0.85,0.50,0.50,"'SIMULATION OF A 3D BIKE'"); bitmap_output(-0.6,-
1.5,0.50,"PLEASE PRESS S TO START");
glutSwapBuffers();
glFlush();
} void
operations_window()
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT); glClearColor(0,0,0,0);
glColor3f(1.0,1.0,1.0); bitmap_output(-1.25,1.7,0.50,"OPERATIONS THAT CAN BE PERFORMED
BY THE BIKE"); bitmap_output(-1.25,1.2,0.50,"1. RESET THE CAMERA - USE 'R' OR 'r'");
bitmap_output(-1.25,1.0,0.50,"2. ACCELERATE THE BIKE - USE '+'"); bitmap_output(-
1.25,0.8,0.50,"3. DEACCELERATE THE BIKE - USE '-'");
bitmap_output(-1.25,0.6,0.50,"4. TURN RIGHT - USE '2'"); bitmap_output(-
1.25,0.4,0.50,"5. TURN LEFT - USE '1'");
bitmap_output(-1.25,0.2,0.50,"6. ZOOM IN - USE 'UPWARD ARROW'"); bitmap_output(-
1.25,0.0,0.50,"7. ZOOM OUT - USE 'DOWNWARD ARROW'"); bitmap_output(-1.25,-0.2,0.50,"8. MOVE
LEFT - USE 'LEFT ARROW'"); bitmap_output(-1.25,-0.4,0.50,"9. MOVE RIGHT - USE 'RIGHT ARROW'");
bitmap_output(-1.25,-0.6,0.50,"10. USE MOUSE TO CHANGE THE ANGLE OF VIEWING"); bitmap_output(-
1.25,-1.0,0.50,"PLEASE PRESS C TO CONTINUE");
glutSwapBuffers();
glFlush();
int main(int argc,char *argv[])
{ glutInit(&argc,arg
v);
glutInitDisplayMode(GLUT_DOUBLE |
GLUT_RGB); glutInitWindowPosition(100,100);
glutInitWindowSize(WIN_WIDTH,WIN_HEIGHT);
glutCreateWindow("Bike");
init();
glutDisplayFunc(welcome_window);
glutReshapeFunc(reshape); glutIdleFunc(idle);
glutSpecialFunc(special);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutPassiveMotionFunc(passive);
glutSetCursor(GLUT_CURSOR_CROSSHAIR);
glutMainLoop();

Bike Code

Uploaded by

Copyright:

Available Formats

Bike Code

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Bike Code

Uploaded by

Copyright:

Available Formats

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

* Beginning of the header file "bike.h"

#define WIN_WIDTH 1920

#define WIN_HEIGHT 1080

#define BIKE_LENGTH 3.3f

#define ROD_RADIUS 0.05f

#define GAS_TANK 0.3f

#define RADIUS_WHEEL 1.0f

#define TUBE_WIDTH 0.20f

#define RIGHT_ROD 2.35f

#define RIGHT_ANGLE 33.0f

#define MIDDLE_ROD 1.8f

#define MIDDLE_ANGLE 125.0f

#define BACK_CONNECTOR 0.5f

#define LEFT_ANGLE 50.0f

#define WHEEL_OFFSET 0.11f

#define WHEEL_LEN 0.8f

#define FRONT_ROD 2.5f

#define CRANK_ROD 1.9f

#define CRANK_RODS 2.5f

#define CRANK_ANGLE 0.0f

#define HANDLE_ROD 1.2f

#define FRONT_INCLINE 38.0f

#define HANDLE_LIMIT 30.0f

#define INC_STEERING 2.0f

#define INC_SPEED 0.05f

* All the Global Variables are Here

* Bike - related variables

GLfloat pedalAngle, speed, steering;

* User view related variables

* Mouse related variables

* Bike position related

void welcome_window(); void

operations_window(); void ZCylinder(GLfloat

radius,GLfloat length); void

XCylinder(GLfloat radius,GLfloat length);

void drawFrame(void); void gear( GLfloat

inner_radius, GLfloat outer_radius, GLfloat

width,GLint teeth, GLfloat tooth_depth ); void

drawChain(void); void drawPedals(void); void

drawTyre(void); void drawSeat(void); void

init(void); void reset(void); void display_bike(void);

void idle(void); void updateScene(void); void

landmarks(void); void special(int key,int x,int y);

void keyboard(unsigned char key,int x,int y);

void mouse(int button,int state,int x,int y);

void motion(int x,int y); GLfloat

GLfloat angleSum(GLfloat, GLfloat);

* End of the header file

* Start of the source file "bike.c"

void ZCylinder(GLfloat radius,GLfloat length)

void XCylinder(GLfloat radius,GLfloat length)

// called by idle() void

GLfloat xDelta, zDelta; //Distance

GLfloat sin_steering, cos_steering;

// if the tricycle is not moving then do nothing

if(speed < 0.0f)

pedalAngle = speed = 0.0f;

// otherwise, calculate the new position of the tricycle