Internal combustion engine - IC engine - OpenGL Computer Graphics Project

In this post we are going to referring to a project that involves computer graphics related to an internal combustion (IC) engine in particular petrol engine.We are going to focus on the design of engine components, simulations of the engine cycle and will going to show visualizations of how the internal combustion (IC) engine works.

An internal combustion engine (IC Engine) is a type of heat engine that generates power by burning (using oxidizer usually air) fuel (typically gasoline(petrol), diesel, or natural gas etc) inside a combustion chamber. IC engines are used in many vehicles, including cars, motorcycles, trucks, and airplanes. Below is Figure of an Typical  IC engine.

Before going to OpenGL Computer Graphics Project for IC engine let us know some more information about Internal combustion engine.

Here’s a breakdown of how an internal combustion engine works:

1. Intake: The engine draws in a mixture of fuel and air into the combustion chamber.

2. Compression: The intake valve closes, and the piston moves upwards, compressing the fuel-air mixture. This increases the pressure and temperature of the mixture.

3. Power/Combustion: A spark plug ignites the compressed fuel-air mixture, causing a controlled explosion. This explosion pushes the piston down, which creates the mechanical energy to power the engine.

4. Exhaust: The exhaust valve opens, and the piston moves upwards again to expel the combustion gases out of the cylinder.

The cycle repeats continuously, with pistons moving up and down, creating the power needed to drive a vehicle or perform work. There are two common types of internal combustion engines:

• Two-stroke engines: Complete a power cycle with two strokes of the piston (one up and one down).
• Four-stroke engines: Complete a power cycle in four strokes (intake, compression, power, and exhaust).

Usages : 

Keyboard: 'Space' : stop/start Engine 

                    '+' :  Speed up Engine 

                     '-' :  Speed down Engine

Code : 

//Simple Program:
#include<stdlib.h>
#include<GL/glut.h>
#include <math.h>

void *font = GLUT_BITMAP_TIMES_ROMAN_24;
char buff[10];
void *fonts[] =
{
  GLUT_BITMAP_9_BY_15,
  GLUT_BITMAP_TIMES_ROMAN_10,
  GLUT_BITMAP_TIMES_ROMAN_24
};
int cc=25,cb=65,s=0,speed=30,status=1;
float pointer=25;
typedef struct
{ GLfloat x,y;} Pt;
Pt  q1, q2,q3,q4;
GLfloat colors[][3] = {{0.5,0.5,0.5},{0.5,0.5,0.5},{0.8,0.8,0.8},{0.8,0.8,0.8},{0.8,0.8,0.8},{0.4,0.4,0.4}};
void init()
{
	glClearColor(0.0,0,0,0.0);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(0.0,499.0,0.0,499.0);
    glutPostRedisplay();
}

void DrawLine(Pt n1, Pt n2)
     {

        glBegin(GL_LINES);
 for (int i=0;i<3;i++){
       glVertex2f(n1.x+i, n1.y+i);
       glVertex2f(n2.x+i, n2.y+i);
 }
       glEnd();
  //     glFlush();

     }
void point (float x,float y){
   glPointSize(10.0f);
	glBegin(GL_POINTS);
	glVertex2f(x,y);
glEnd();
//glFlush();

}
void rect(Pt n1, Pt n2,Pt n3, Pt n4){
    glBegin(GL_QUADS);        // Draw The Cube Using quads
//    glColor3f(0.0f,1.0f,0.0f);    // Color Blue
    glVertex2f(n1.x, n1.y);
    glVertex2f(n2.x, n2.y);
    glVertex2f(n3.x, n3.y);
    glVertex2f(n4.x, n4.y);
    glEnd();            // End Drawing The Cube
//glFlush();
}

void Circle(float cx, float cy, float r, int num_segments,int h) {
    //glColor3f(0.0,0.0,1.0);
    float xx,yy,n;
    if(h==1)
    glBegin(GL_LINE_LOOP);//  for not filled circle
    else
    glBegin(GL_TRIANGLE_FAN);

    for (int ii = 0; ii < num_segments; ii++)   {
        float theta = 2.0f * 3.1415926f * float(ii) / float(num_segments);//get the current angle
        float x = r * cosf(theta);//calculate the x component
        float y = r * sinf(theta);//calculate the y component
        glVertex2f(x + cx, y + cy);//output vertex

      }
    glEnd();

}
void quad(Pt n1, Pt n2,int i){
    glBegin(GL_QUADS);        // Draw The Cube Using quads
 //   glColor3f(0.0f,1.0f,0.0f);    // Color Blue
    glVertex2f(n1.x-i, n1.y);
    glVertex2f(n1.x+i, n1.y);
    glVertex2f(n2.x+i, n2.y);
    glVertex2f(n2.x-i, n2.y);
    glEnd();            // End Drawing The Cube
//glFlush();
}

void quadd(Pt n1, Pt n2){
    glBegin(GL_QUADS);        // Draw The Cube Using quads
    //glColor3f(0.0f,1.0f,0.0f);    // Color Blue
    glVertex2f(n1.x, n1.y-5);
    glVertex2f(n1.x, n1.y+5);
    glVertex2f(n2.x, n2.y+5);
    glVertex2f(n2.x, n2.y-5);
    glEnd();            // End Drawing The Cube
//glFlush();
}

void rectangle(Pt n1, Pt n2,int i){
	glBegin(GL_QUADS);        // Draw The Cube Using quads
    //glColor3f(0.0f,1.0f,0.0f);    // Color Blue
    glVertex2f(n1.x-i, n1.y);
    glVertex2f(n2.x+i, n1.y);
    glVertex2f(n2.x+i, n2.y);
    glVertex2f(n1.x-i, n2.y);
    glEnd();            // End Drawing The Cube
//glFlush();
}
void outlet(float x,float y){
    glColor3fv(colors[3]);
glBegin(GL_TRIANGLE_FAN);
if(s==1 )
{   if(cc>=75 && cc<100 || cc>=0 && cc<=25)
    glColor3f(0.9,0.96,0.96);

}
if(s==0){
   if(cc>25 && cc<=50){
        float r=(cc-25)*0.006;
        glColor3f(0.9-(r),0.95-(r),0.95-(r));
    }}

        float cx=x+50,cy=y+225,r=32;
    for (int ii = 0; ii < 100; ii++)   {
        float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle
        float x = r * cosf(theta);//calculate the x component
        float y = r * sinf(theta);//calculate the y component
        if(ii>=25 && ii<=50)
        glVertex2f(x + cx, y + cy);//output vertex

      } r=10;
    for (int ii = 100; ii >=0; ii--)   {
        float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle
        float x = r * cosf(theta);//calculate the x component
        float y = r * sinf(theta);//calculate the y component
        if(ii>=25 && ii<=50)
        glVertex2f(x + cx, y + cy);//output vertex

      }
        glEnd();
        glBegin(GL_TRIANGLE_FAN);
        glVertex2f(x+100, y+234);
        glVertex2f(x+100, y+256);
        glVertex2d(x+41, y+256);
        glVertex2f(x+41, y+234);
        glEnd();

}

void outletcover(float x,float y){
glColor3fv(colors[1]);
//glColor3f(0,0,0);
glBegin(GL_TRIANGLE_FAN);

        float cx=x+50,cy=y+225,r=34;
    for (int ii = 0; ii < 100; ii++)   {
        float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle
        float x = r * cosf(theta);//calculate the x component
        float y = r * sinf(theta);//calculate the y component
        if(ii>=25 && ii<=50)
        glVertex2f(x + cx, y + cy);//output vertex

      } r=8;
    for (int ii = 100; ii >=0; ii--)   {
        float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle
        float x = r * cosf(theta);//calculate the x component
        float y = r * sinf(theta);//calculate the y component
        if(ii>=25 && ii<=50)
        glVertex2f(x + cx, y + cy);//output vertex

      }
        glEnd();
        glBegin(GL_TRIANGLE_FAN);
        glVertex2f(x+100, y+232);
        glVertex2f(x+100, y+259);
        glVertex2d(x+42, y+259);
        glVertex2f(x+42, y+232);
        glEnd();

}
void Crank(float cx, float cy, float r, int num_segments) {
    glColor3f(0.0,0.0,1.0);
    float xx,yy,n;
    glBegin(GL_LINE_LOOP);//  for not filled circle
    //glBegin(GL_TRIANGLE_FAN);
    for (int ii = 0; ii < num_segments; ii++)   {
        float theta = 2.0f * 3.1415926f * float(ii) / float(num_segments);//get the current angle
        float x = r * cosf(theta);//calculate the x component
        float y = r * sinf(theta);//calculate the y component
      if(ii==cc){
       xx=x+ cx;
                yy=y+ cy;    }
      }
    glEnd();
    if(cc>=0 && cc<25)
    {n=cy+125+(cc*1.4);}
    else if(cc>=25 && cc<=75)
        {n=cy+160-((cc-25)*1.4);}
     else if(cc>75 && cc<100)
    {n=cy+90+((cc-75)*1.4);}


    glColor3f(0.0f,1.0f,0.0f);
    q1.x=xx;
    q1.y=yy;
                    /*glColor3f(0.0f,0.0f,1.0f);
                    q2.x=cx;
                    q2.y=cy;
                    quad(q1,q2,5);
                    q2.x=cx;
                    q2.y=cy;
                    quadd(q1,q2);*/
    glColor3f(0.4f,0.4f,0.4f);
    q2.x=cx;
    q2.y=n;
    quad(q1,q2,5);
    q1.x=cx;
    q1.y=n;
    q2.x=cx;
    q2.y=n+40;
    //glColor3f(0.0f,0.0f,1.0f);
    glColor3fv(colors[0]);
    quad(q1,q2,45);
    glColor3f(0.4f,0.4f,0.4f);


    glColor3f(0.4f,0.4f,0.4f);
    q1.x=cx;
    q1.y=n+18;
    q2.x=cx;
    q2.y=n+28;
    //quad(q1,q2,45);
    q1.x=cx;
    q1.y=n+30;
    q2.x=cx;
    q2.y=n+39;
    //quad(q1,q2,45);
    Circle(xx,yy,10,100,0);//crank connector
    Circle(cx,n+10,10,100,0);//piston connecting rod


}

void Crankrod(float cx, float cy, float r, int num_segments) {
    float xx,yy,n,xxx,yyy,flg=0;
    glBegin(GL_TRIANGLE_FAN);
    for (int ii = 0; ii < num_segments; ii++)   {
        float theta = 2.0f * 3.1415926f * float(ii) / float(num_segments);//get the current angle
        float x = r * cosf(theta);//calculate the x component
        float y = r * sinf(theta);//calculate the y component

      if(ii>=cb && ii<=(cb+20)){
                glVertex2f(x + cx, y + cy);//output vertex
                if(flg!=1)
                {xxx=x+cx;
                yyy=y+cy;}
    }
     if(cb>=80 && ii<=(20-(100-cb))){
                glVertex2f(x + cx, y + cy);//output vertex
                xxx=x+cx;
                yyy=y+cy;
                flg=1;
    }
    if(ii==cb){
                xx=x+ cx;
                yy=y+ cy;
    }
    }
    glEnd();

    q1.x=xx;
    q1.y=yy;
    q2.x=xxx;
    q2.y=yyy;
    q3.x=cx;
    q3.y=cy;
    q4.x=cx;
    q4.y=cy;

    rect(q1,q2,q3,q4);


    //glColor3f(0.0,0.0,0.0);

    //Circle(xx,yy,3,100,0);

}void valve(float x,float y){

   float p=0;
    if(s==0){
     if(cc>=25 && cc<=50)
        p=-(cc-25)*0.6;
     else if(cc>50 && cc<75)
        p=-15+(cc-50)*0.6;
    }
                    //glColor3f(1.0f,0.0f,0.0f);
                    glColor3fv(colors[5]);
                    q1.x=x-30;
                    q1.y=y+225+p;
                    q2.x=x-30;
                    q2.y=y+220+p;
                    quad(q1,q2,10);
                    q1.x=x-30;
                    q1.y=y+225+p;
                    q2.x=x-30;
                    q2.y=y+276+p;
                    quad(q1,q2,2);


     p=0;
     if(s==1){
  if(cc>=0 && cc<25)
        p=-15+(cc)*0.6;
    if(cc>=75 && cc<100)
    p=-(cc-75)*0.6;

    }               q1.x=x+30;
                    q1.y=y+225+p;
                    q2.x=x+30;
                    q2.y=y+220+p;
                    quad(q1,q2,10);
                    q1.x=x+30;
                    q1.y=y+225+p;
                    q2.x=x+30;
                    q2.y=y+276+p;
                    quad(q1,q2,2);


}
void cover(float x,float y){// x=900;y=500;
//glColor3f(1.0,1.0,0.0);
glBegin(GL_TRIANGLE_FAN);
glVertex2d(x-120,y+60);
glVertex2d(x-55,y+125);
glVertex2d(x+55,y+125);
glVertex2d(x+120,y+60);
glVertex2d(x+120,y-120);
glVertex2d(x-120,y-120);
glEnd();

glBegin(GL_TRIANGLE_FAN);
//glVertex2d(780,560);
glVertex2d(x-55,y+125);
glVertex2d(x-55,y+225);
glVertex2d(x-20,y+250);
glVertex2d(x+20,y+250);
glVertex2d(x+55,y+225);
glVertex2d(x+55,y+125);
glEnd();

}
void innlet(float x,float y){
    glColor3fv(colors[3]);

glBegin(GL_TRIANGLE_FAN);
if(s==0 )
{   if(cc>=27 && cc<75)
    glColor3f(0.0,0.5,1.0);
    if(cc>=75 && cc<100){
        float r=(cc-75)*0.032;
        glColor3f(0.0+r,0.5+(r/2.66),1.0-(r/4));
    }
}
        float cx=x-50,cy=y+225,r=32;
    for (int ii = 0; ii < 100; ii++)   {
        float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle
        float x = r * cosf(theta);//calculate the x component
        float y = r * sinf(theta);//calculate the y component
        if(ii>=0 && ii<=25)
        glVertex2f(x + cx, y + cy);//output vertex

      }r=10;
    for (int ii = 100; ii >=0; ii--)   {
        float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle
        float x = r * cosf(theta);//calculate the x component
        float y = r * sinf(theta);//calculate the y component
        if(ii>=0 && ii<=25)
        glVertex2f(x + cx, y + cy);//output vertex

      }
    glEnd();
        glBegin(GL_TRIANGLE_FAN);
        glVertex2f(x-100, y+256);
        glVertex2f(x-100, y+235);
        glVertex2d(x-49,y+235);
        glVertex2f(x-49, y+256);
        glEnd();

}
void innletcover(float x,float y){
    glColor3fv(colors[1]);

glBegin(GL_TRIANGLE_FAN);
        float cx=x-50,cy=y+225,r=34;
    for (int ii = 0; ii < 100; ii++)   {
        float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle
        float x = r * cosf(theta);//calculate the x component
        float y = r * sinf(theta);//calculate the y component
        if(ii>=0 && ii<=25)
        glVertex2f(x + cx, y + cy);//output vertex

      }r=8;
    for (int ii = 100; ii >=0; ii--)   {
        float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle
        float x = r * cosf(theta);//calculate the x component
        float y = r * sinf(theta);//calculate the y component
        if(ii>=0 && ii<=25)
        glVertex2f(x + cx, y + cy);//output vertex

      }
    glEnd();

        glBegin(GL_TRIANGLE_FAN);
        glVertex2f(x-100, y+259);
        glVertex2f(x-100, y+232);
        glVertex2d(x-47,y+232);
        glVertex2f(x-47, y+259);
        glEnd();

}
void spark(float x,float y){
glColor3f(1,1,0.1);
glBegin(GL_TRIANGLE_FAN);
//glBegin(GL_LINE_LOOP);
//glVertex2f(x-5,y+220);
glVertex2f(x+3,y+220);
glVertex2f(x+16,y+225);
glVertex2f(x+10,y+220);
glVertex2f(x+17,y+215);
glVertex2f(x-3,y+220);
glVertex2f(x-16,y+225);
glVertex2f(x-11,y+220);
glVertex2f(x-17,y+215);
glVertex2f(x+3,y+220);
glVertex2f(x+5,y+220);
glVertex2f(x,y+210);
glVertex2f(x-5,y+220);
glEnd();
}
void plug(float x,float y){ //float x=217,y=301;
   glColor3f(0.3,0.3,0.3);
 glBegin(GL_TRIANGLE_FAN);
        glVertex2f(x-2, y+19);
        glVertex2f(x+3, y+19);
        glVertex2f(x+3, y+24);
        glVertex2f(x-2, y+24);
    glEnd();
    glBegin(GL_TRIANGLE_FAN);
        glVertex2f(x-7, y+19);
        glVertex2f(x+8, y+19);
        glVertex2f(x+8, y+1);
        glVertex2f(x-7, y+1);
    glEnd();
glColor3f(0.0,0.0,0.0);

    glBegin(GL_QUADS);
        glVertex2f(x-17, y-1);
        glVertex2f(x+19, y-1);
        glVertex2f(x+19, y+1);
        glVertex2f(x-17, y+1);
    glEnd();
    glColor3f(1.8,1.8,1.0);
glBegin(GL_TRIANGLE_FAN);
        glVertex2f(x-9, y-1);
        glVertex2f(x+10, y-1);
        glVertex2f(x+10, y-31);
        glVertex2f(x-9, y-31);
    glEnd();
     glColor3f(0.0,0.0,0.0);
    glBegin(GL_LINES);
        for(int i=0;i<5;i++)
   {
            glVertex2f(x+10, (y-1)-(5*i));
            glVertex2f(x-9, (y-6)-(5*i));
   }
    glEnd();
     glColor3f(1.8,1.8,1.0);

    glPointSize(7.0f);
    glBegin(GL_POINTS);
    glVertex2d(x+1,y-31);
    glEnd();
    glBegin(GL_LINES);
    glVertex2d(x+6,y-32);
    glVertex2d(x+6,y-41);
    glEnd();
    glBegin(GL_LINES);

    glVertex2d(x-2,y-41);
    glVertex2d(x+6,y-41);

    glEnd();
 glColor3f(0.3,0.3,0.3);
  glBegin(GL_LINES);
        float cx=x+25,cy=y+24,r=25;
        for (int ii = 0; ii < 100; ii++)   {
        float theta = 2.0f * 3.1415926f * float(ii) / float(100);//get the current angle
        float x = r * cosf(theta);//calculate the x component
        float y = r * sinf(theta);//calculate the y component
        if(ii>=25 && ii<=50)
        glVertex2f(x + cx, y + cy);//output vertex

         }
    glEnd();
}


void fuel(float x,float y){
    float j,i=x,k=y+227,l,flag=0;
    if(s==0){k=y+224;
            if( cc>25 && cc<=75){
    l=y+170-((cc-25)*1.4);
    flag=1;

    glColor3f(0.0,0.5,1.0);//fuel color
            }
            if( cc>75 && cc<100){
    l=y+100+((cc-75)*1.4);
    flag=1;
    float rr=(cc-75)*0.02;
    glColor3f(rr,0.5-(rr/2),1-rr);//fuel color
            }
            if( cc>=0 && cc<25){
    l=y+135+(cc*1.4);
    flag=1;

    float rr=(cc)*0.02;

    glColor3f(rr+0.5,0.25-(rr/2),0.5-rr);//fuel color
            }
    }


     if(s==1){
            k=(y+225);
        if(cc>=25 && cc<=75){
    l=y+170-((cc-25)*1.4);
    flag=1;
    float rr=(cc-25)*0.02;
    if(rr>=0.95)
        rr=0.95;
    glColor3f(1-(rr*0.1),0+rr,0+rr);

        }
            if( cc>75 && cc<100){ l=y+100+((cc-75)*1.4);
            flag=1;
 glColor3f(0.9,0.95,0.95);

            }
            if( cc>=0 && cc<=25){ l=y+135+(cc*1.4);
            flag=1;

 glColor3f(0.9,0.95,0.95);//gas color
 }

    }

    if(flag==1){
    glBegin(GL_LINES);
    for(j=k;j>l;j--)
    {
        glVertex2f(i-43,j);
        glVertex2f(i+44,j);
    }
    glEnd();
    }

}

void board(float x,float y){
//glColor3f(0.0,1.0,1.0);
glColor3f(0.95,1,1);

glBegin(GL_QUADS);
glVertex2f(x-450,y-250);
glVertex2f(x+450,y-250);
glVertex2f(x+450,y+450);
glVertex2f(x-450,y+450);
glEnd();
//glColor3f(0.85,1,1);
glColor3f(0.2,.8,.5);

glBegin(GL_QUADS);
glVertex2f(x-400,y-200);
glVertex2f(x+400,y-200);
glVertex2f(x+400,y+400);
glVertex2f(x-400,y+400);
glEnd();

}

void smallboard(float x,float y){
//glColor3f(0.0,1.0,1.0);
glColor3f(0.95,1,1);

glBegin(GL_QUADS);
glVertex2f(x-200,y-200);
glVertex2f(x+200,y-200);
glVertex2f(x+200,y+200);
glVertex2f(x-200,y+200);
glEnd();
//glColor3f(0.85,1,1);
glColor3f(0.2,.8,.5);

glBegin(GL_QUADS);
glVertex2f(x-160,y-160);
glVertex2f(x+160,y-160);
glVertex2f(x+160,y+160);
glVertex2f(x-160,y+160);
glEnd();

}
/*void board(float x,float y){
glColor3f(0.3,0.3,0.3);
//glColor3f(0.95,1,1);

glBegin(GL_QUADS);
glVertex2f(x-550,y-250);
glVertex2f(x+550,y-250);
glVertex2f(x+550,y+450);
glVertex2f(x-550,y+450);
glEnd();
glColor3f(1.0,1.0,1.0);
//glColor3f(0.2,.8,.5);

glBegin(GL_QUADS);
glVertex2f(x-500,y-200);
glVertex2f(x+500,y-200);
glVertex2f(x+500,y+400);
glVertex2f(x-500,y+400);
glEnd();

}*/

void text(int x, int y, char *string,int j)
{
  int len, i;

  glRasterPos2f(x, y);
  len = (int) strlen(string);
  for (i = 0; i < len; i++) {
    glutBitmapCharacter(fonts[j], string[i]);
  }
}
void indicator(float cx, float cy, float r, int num_segments,int h) {
    //glColor3f(0.0,0.0,1.0);
    float xx,yy,n;
    glBegin(GL_TRIANGLE_FAN);
        glVertex2f(cx, cy);//output vertex

    for (int ii = 0; ii <= num_segments; ii++)   {
        float theta = 2.0f * 3.1415926f * float(ii) / float(num_segments);//get the current angle
        float x = r * cosf(theta);//calculate the x component
        float y = r * sinf(theta);//calculate the y component
        if(ii>=h && ii<=(h+25))
        glVertex2f(x + cx, y + cy);//output vertex

      }
    glEnd();


}
void kk(float cx, float cy, float r, int num_segments){
    for (int ii = 0; ii <= num_segments; ii++)   {
        float theta = 2.0f * 3.1415926f * float(ii) / float(num_segments);//get the current angle
        float x = r * cosf(theta);//calculate the x component
        float y = r * sinf(theta);//calculate the y component
        if(ii==pointer || ii==(pointer-0.5))
        glVertex2f(x + cx, y + cy);//output vertex

      }

}
void tip(float cx, float cy, float r, int num_segments){
    float xx,yy,n;
    glBegin(GL_TRIANGLE_FAN);
        glVertex2f(cx-5, cy-5);//output vertex
        kk(cx,cy,r,num_segments);
      glVertex2f(cx+5, cy-5);//output vertex


    glEnd();

    glBegin(GL_TRIANGLE_FAN);
        glVertex2f(cx-5, cy-5);//output vertex
kk(cx,cy,r,num_segments);
      glVertex2f(cx-5, cy+5);//output vertex


    glEnd();

    glBegin(GL_TRIANGLE_FAN);
        glVertex2f(cx-5, cy+5);//output vertex
kk(cx,cy,r,num_segments);
      glVertex2f(cx+5, cy+5);//output vertex


    glEnd();

    glBegin(GL_TRIANGLE_FAN);
        glVertex2f(cx+5, cy-5);//output vertex
kk(cx,cy,r,num_segments);
      glVertex2f(cx+5, cy+5);//output vertex


    glEnd();




}
void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	//glClear(GL_COLOR_BUFFER_BIT);

int x=800,y=500;

    //Circle(x, y, 100, 100,0);
 glColor3f(0.0,1.0,1.0);
    board(x,y);
    glColor3fv(colors[1]);
    cover(x,y);
    glColor3f(0.8,0.8,0.8);
    innletcover(x,y);
    innlet(x,y);
    outletcover(x,y);
    outlet(x,y);
   // glColor3f(1.0,1.0,1.0);
    glColor3fv(colors[4]);
    Circle(x, y, 110, 100,0);


    q1.x=x-44;
    q1.y=y+100;
    q2.x=x-44;
    q2.y=y+225;
    q3.x=x+44;
    q3.y=y+225;
    q4.x=x+44;
    q4.y=y+100;

    rect(q1,q2,q3,q4); //inner cylinder
     fuel(x,y);
    glColor3f(0.0,0.0,1.0);

    //reectangle();
    //point(x,y+325);

 glColor3fv(colors[0]);
	//Crankrod(x, y, 65, 100);
    Circle(x, y, 50, 100,0);
  glColor3fv(colors[2]);
    Crank(x, y, 35, 100);
    glColor3f(0.0,0.0,1.0);
    valve(x,y);
    plug(x,y+253);
    if(s==0 && cc>=22 && cc<=25  )
        spark(x+1,y-2);
    if(s==1 && cc<=28 && cc>=25  )
        spark(x+1,y-2);
// title
    glColor3f(0.0,0.0,1.0);
    text(x-115,y+415,"IC Petrol Engine",2);
 y+=150;
    smallboard(x+700,y);
    glColor3f(0.3,0.3,0.3);
    Circle(x+700, y, 145, 100,0);
        glColor3f(0.9,0.95,0.95);
        indicator(x+700, y, 140, 100,0); //exhaust
    glColor3f(0.0,0.5,1.0);
     indicator(x+700, y, 140, 100,25); //suction
    glColor3f(0.8,0.5,0.5);
        indicator(x+700, y, 140, 100,50);//compression
    glColor3f(0.9,1.0,0.5);
        indicator(x+700, y, 140, 100,75);// working
    glColor3f(0.3,0.3,0.3);
    Circle(x+700, y, 15, 100,0);
    //glColor3f(0.0,0.0,0.0);

    tip(x+700, y, 100, 100);

    glColor3f(0.0,0.0,1.0);
    text(x+600,y+170,"Stroke Indicator",2);

    //lables
    glColor3f(0.0,0.5,1.0);
     point(x+520,y-240);

    glColor3f(0.5,0.9,1.0);
    text(x+540,y-245,"Suction Stroke",0);

    glColor3f(0.8,0.5,0.5);
     point(x+520,y-260);

    glColor3f(0.5,0.9,1.0);
    text(x+540,y-265,"Compression Stroke",0);

    glColor3f(0.9,1.0,0.5);
     point(x+520,y-280);

    glColor3f(0.5,0.9,1.0);
    text(x+540,y-285,"Working Stroke",0);

    glColor3f(0.9,0.95,0.95);
     point(x+520,y-300);

    glColor3f(0.5,0.9,1.0);
    text(x+540,y-305,"Exhaust Stroke",0);
    text(x-510,y-450,"Press 'space' to start/stop    Press '+' to speedup engine    Press '-' to slowdown engine",0);


    glFlush();

    //quad();



}
void start(){
    if(status==1)
{   cb++;
    cc++;
    pointer+=0.5;
    }
    if(cc==100)
    {
        cc=0;

    }
    if(pointer==100)
    {
        pointer=0;

    }
    if(cb==100) cb=0;
    display();

      //Game title

    if(cc==25){
        if(s==0)
            s=1;
        else
            s=0;
    }

    Sleep(speed);

}

void keypress(unsigned char key, int x,int y){
       if (key=='+') {speed--;
                                if(speed<=0) speed=0;}
       if (key=='-') {speed++;if(speed>=500) speed=500;}
       if(key==' ') {if(status==0) status=1; else status=0; }}
void myReshape(int w,int h)
{

	glViewport(0,0,w,h);
	glMatrixMode(GL_PROJECTION);
    glOrtho(-2.0,2.0,-2.0*(GLfloat)h/(GLfloat)w,2.0*(GLfloat)h/(GLfloat)w,-10.0,10.0);
	glMatrixMode(GL_PROJECTION);
}


int main(int argc,char **argv)
{
	glutInit(&argc,argv);
	glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
	glutInitWindowSize (600, 600);
	glutCreateWindow("Introduction to Open GL");
	glutReshapeFunc(myReshape);
	glutKeyboardFunc(keypress);
	glutDisplayFunc(display);
	glutIdleFunc(start);
	init();
    glutMainLoop();
}

Here are a few common components that could be part of such the OpenGL Computer Graphics Project:

1. 3D Visualization: Creating a detailed 3D model of a petrol engine, showing key parts like the pistons, crankshaft, valves, and camshaft.

2. Animation of Engine Cycle: Simulating and animating the stages of the engine cycle, like intake, compression, power, and exhaust strokes.

3. Computational Fluid Dynamics (CFD) Simulation: Visualizing airflow and combustion processes inside the engine, potentially showing how fuel and air mix, ignite, and exhaust gases are expelled.

4. Performance Simulation: Using computer graphics to illustrate how engine performance (such as horsepower, torque, fuel consumption) changes with different variables (e.g., RPM, throttle position).

OpenGL Solar System Simulator

In OpenGL projects blog we are going to demonstrate solar system simulator with Verlet. Here we are using OpenGL for displaying coded and compiled in Visual Studio. We have used glm and glew in this project with MS XML Parser.

We are going to see the important concepts used in this project - 

Object oriented programming use the Concept of Class hence here we are going to demonstrate the same. First we are using classes which are getting generated in this application and get done by compiler.

#SolarSystem

Others programs -

1. Mini Solar System Computer Graphics Programs

2. solar System Mini-Project in OpenGL

 3.3D Solar System OpenGL graphics program

For this Opengl programming project we need to have the supporting liabrary ie  glm and glew. We can download the mentioned liablrary and have to installed them LIBs folder of PC. According to the directory/destination of the glu/gl/ other supporting filles we need to adjust our project settings accordingly.

Download the above libraries from the link provided below - 

glm : http://glm.g-truc.net/0.9.7/index.html

glew: http://glew.sourceforge.net/

mfc: This will be already included in the Visual Studio package, if not there kindly check Visual Studio installation guide.

Download Source code  -  https://github.com/aromanro/SolarSystem

Video  - 

New Village Scenery Computer Graphics Project in OpenGL Source Code

Many of the University including VTU have 'The Department of Computer Science and Engineering' which have Lab projects for students to show thier learning skill which got during thier course study. 

VTU Computer Graphics and Visualization Laboratory [15CSL68]

Above mentioned link have the lab programs prescribed by VTU under it course id mentioned have computer graphics project in OpenGL. Under this program students use thier learning ability to show of thier excellence, what they learnt in the course. Many students keeping in focus special efforts to impart  thier knowledge to give best projects.

We in this article we are going to show one of the best project in Computer Graphics Project in OpenGL with free source code. The name of the Project is New Village Scenery. 

Project Description:

In this Computer Graphics Project in OpenGL with free Source Code are going to draw sun, clouds, sky, river, boats, fence, trees, huts. In this projects we demonstrate the moving clouds in the sky and moving boats in the river,  Above is achived by using circle, lines traingle and spheres.

Draw Sky

 ///sky///

    glBegin(GL_POLYGON);

    glColor3ub(112,160,228);

    glVertex2f(38.0,3.0);

    glVertex2f(38.0,14.0);

    glVertex2f(-12.0,14.0);

    glVertex2f(-12.0,3.0);

    glEnd();

Draw the Sun

    /// Sun

    glPushMatrix();

    glColor3d(255,0,0);

    glTranslatef(1.0, 7.0, 0);

    glutSolidSphere(1.0, 750, 300);

    glPopMatrix();

See Also

1. Simple City Scenery Opengl Computer Graphics Project

2. Transformers - Free OpenGL Source code

3. Day and Night OpenGL Computer graphics Project

Implementation 

We use GL_QUADS with tranlation in opengl to draw most of the scenery in this new village scenery opengl projects program. As name suggested quads means fourt vertices. We use the glvertex in opengl to join the vertices and make the objects. Below is how vertices are used in opengl.

Draw Components

In this project we are going to use the different functions to implement the different object like sun in the program. void DrawAllComponents() functions is used to draw all the mentioned objects required in this program. After we draw all the objects and then we call them in the display function - void display(void)

After above functions are implemented we call the keyboard and mouse functions to implement the user interactions and call all of them in main functions.

User Interaction

In this opengl project below is user interactions

Mouse interactions

Left Mouse button - Increase the Movement of clouds and boats

Right Mouse button - Decrease the Movement of clouds and boats

Key Interactions

s - to stop the boat

r -  to run the boat again

Source code and Reports Computer Graphics Project in OpenGL 

Here you can download computer graphics projects with source code and reports.

Below is soure code -

#include<windows.h>

#include <iostream>

#include<GL/gl.h>

#include <GL/glut.h>

#include <math.h>

#include<windows.h>

float moveC = 0.0f;

float moveB1 = 0.0f;

float moveB2 = 0.0f;

float speed = 0.02f;

void DrawAllComponents()

{

    glClearColor(1.0f,1.0f,1.0f,1.0f);

    glClear(GL_COLOR_BUFFER_BIT);

    glColor3d(1,0,0);

    glLoadIdentity();

    gluOrtho2D(-12,38,-19,14);//range

    glMatrixMode(GL_MODELVIEW);

    ///sky///

    glBegin(GL_POLYGON);

    glColor3ub(112,160,228);

    glVertex2f(38.0,3.0);

    glVertex2f(38.0,14.0);

    glVertex2f(-12.0,14.0);

    glVertex2f(-12.0,3.0);

    glEnd();

    /// Sun

    glPushMatrix();

    glColor3d(255,0,0);

    glTranslatef(1.0, 7.0, 0);

    glutSolidSphere(1.0, 750, 300);

    glPopMatrix();

    ///Cloud-01

    glPushMatrix();

    glTranslatef(moveC,0.0f,0.0f);

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(1.0, 6.0, 0);

    glutSolidSphere(0.7, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(1.0, 7.0, 0);

    glutSolidSphere(0.7, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(2.0, 7.0, 0);

    glutSolidSphere(0.7, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(2.0, 6.0, 0);

    glutSolidSphere(0.7, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(0.0, 6.5, 0);

    glutSolidSphere(0.7, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(3.0, 6.5, 0);

    glutSolidSphere(0.7, 250, 250);

    glPopMatrix();

    glPopMatrix();

    ///cloud-02

    glPushMatrix();

    glTranslatef(moveC,0.0f,0.0f);

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(15.0, 9.0, 0);

    glutSolidSphere(0.8, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(15.0, 8.0, 0);

    glutSolidSphere(0.8, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(16.0, 8.0, 0);

    glutSolidSphere(0.8, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(16.0, 9.0, 0);

    glutSolidSphere(0.8, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(14.0, 8.5, 0);

    glutSolidSphere(0.8, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(17.0, 8.5, 0);

    glutSolidSphere(0.8, 250, 250);

    glPopMatrix();

    glPopMatrix();

    ///cloud-03

    glPushMatrix();

    glTranslatef(moveC,0.0f,0.0f);

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(22.0, 8.0, 0);

    glutSolidSphere(0.75, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(22.0, 7.0, 0);

    glutSolidSphere(0.75, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(23.0, 8.0, 0);

    glutSolidSphere(0.75, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(23.0, 7.0, 0);

    glutSolidSphere(0.75, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(24.0, 7.5, 0);

    glutSolidSphere(0.75, 250, 250);

    glPopMatrix();

    glPushMatrix();

    glColor3d(255,255,255);

    glTranslatef(21.0, 7.5, 0);

    glutSolidSphere(0.75, 250, 250);

    glPopMatrix();

    glPopMatrix();

    ///See portion

    glPushMatrix();

    glBegin(GL_POLYGON);

    glColor3ub(65,105,225);

    glVertex2f(40.0,-19.0);  /// right-down

    glVertex2f(38.0,-11.0); /// right-top

    glVertex2f(-12.0,-11.0); /// left-top

    glVertex2f(-12.0,-19.0);  /// left-down

    glEnd();

    ///Ground portion

    glBegin(GL_POLYGON);

    glColor3ub(25,128,0);

    glVertex2f(90.0f, -12.5f); /// angle

    glVertex2f(38.0f,-12.0f);  /// right-down

    glVertex2f(38.0f,3.0f); /// right-top

    glVertex2f(-12.0f,3.0f); /// left-top

    glVertex2f(-12.0f,-11.0f);  /// left-down

    glEnd();

    /// House Drawing

    ///1st House

    /// FEG

    glColor3ub(162, 116, 36);

    glBegin(GL_TRIANGLES);

    glVertex2f(-8, -2);

    glVertex2f(-6, 0);

    glVertex2f(-4, -2);

    glEnd();

    /// FGIH

    glColor3ub(214, 42, 50);

    glBegin(GL_QUADS);

    glVertex2f(-8.023, -5.184);

    glVertex2f(-8, -2);

    glVertex2f(-4, -2);

    glVertex2f(-3.999, -7.219);

    glEnd();

    ///ROPQ

    glColor3ub(19, 105, 51);

    glBegin(GL_QUADS);

    glVertex2f(-6.73, -5.67);

    glVertex2f(-6.76, -3.58);

    glVertex2f(-5.19, -3.58);

    glVertex2f(-5.19, -6.62);

    glEnd();

    ///EGKJ

    glColor3ub(124, 85, 17);

    glBegin(GL_QUADS);

    glVertex2f(-6, 0);

    glVertex2f(4, 0);

    glVertex2f(6, -2);

    glVertex2f(-4, -2);

    glEnd();

    ///GLMI

    glColor3ub(156, 9, 16);

    glBegin(GL_QUADS);

    glVertex2f(-4, -2);

    glVertex2f(5.22, -2);

    glVertex2f(5.26, -5.11);

    glVertex2f(-3.99, -7.22);

    glEnd();

    ///VSTU

    glColor3ub(216, 215, 111);

    glBegin(GL_QUADS);

    glVertex2f(-0.39, -6.40);

    glVertex2f(-0.42, -3.62);

    glVertex2f(1.95, -3.58);

    glVertex2f(1.97, -5.86);

    glEnd();

    ///SZA1V

    glColor3ub(19, 105, 51);

    glBegin(GL_QUADS);

    glVertex2f(-0.42, -3.62);

    glVertex2f(0.38, -4.38);

    glVertex2f(0.38, -5.53);

    glVertex2f(-0.39, -6.40);

    glEnd();

    ///TB1C1U

    glColor3ub(19, 105, 51);

    glBegin(GL_QUADS);

    glVertex2f(1.95, -3.58);

    glVertex2f(1.21, -4.38);

    glVertex2f(1.21, -5.46);

    glVertex2f(1.97, -5.86);

    glEnd();

    ///2nd House

    ///S1R1W1

    glColor3ub(0,0,0);

    glBegin(GL_TRIANGLES);

    glVertex2f(8.09,-5.01);

    glVertex2f(10.96,-2.02);

    glVertex2f(14.10, -5.01);

    glEnd();

    ///U1V1Z1W1

    glColor3ub(145, 0, 12);

    glBegin(GL_QUADS);

    glVertex2f(9.15, -5.01);

    glVertex2f(9.14, -9.02);

    glVertex2f(12.85, -9.04);

    glVertex2f(12.84, -5.01);

    glEnd();

    ///A2B2C2D2

    glColor3ub(245, 10, 49);

    glBegin(GL_QUADS);

    glVertex2f(10.36, -6.79);

    glVertex2f(10.35, -8.91);

    glVertex2f(11.59, -8.99);

    glVertex2f(11.58, -6.79);

    glEnd();

    ///1st Tree

    glColor3ub(22, 208, 70);

    glBegin(GL_QUADS);

    glVertex2f(14.88, -6.00);

    glVertex2f(20, 0);

    glVertex2f(24.98, -6.16);

    glVertex2f(21.05, -4.96);

    glVertex2f(19.09, -4.95);

    glEnd();

    ///NWJ1H1

    glColor3ub(191, 158, 24);

    glBegin(GL_QUADS);

    glVertex2f(19.02, -6.06);

    glVertex2f(20.96, -6.09);

    glVertex2f(21, -10.08);

    glVertex2f(19.01, -10.08);

    glEnd();

    /// 2nd Tree

    ///L1K1M1

    glColor3ub(17, 218, 45);

    glBegin(GL_TRIANGLES);

    glVertex2f(27.02, -6.16);

    glVertex2f(30, 0);

    glVertex2f(32.93, -6);

    glEnd();

    ///E1F1P1Q1

    glColor3ub(191, 158, 24);

    glBegin(GL_QUADS);

    glVertex2f(29.09, -6.10);

    glVertex2f(31.03, -6.05);

    glVertex2f(31.05, -10.03);

    glVertex2f(29.06, -9.97);

    glEnd();

    ///Rail Line

    ///N1B

    glColor3ub(155, 29, 29);

    glBegin(GL_QUADS);

    glVertex2f(-12, 2);

    glVertex2f(38, 3);

    glVertex2f(37.98, 2.69);

    glVertex2f(-11.98, 1.71);

    glEnd();

    glColor3ub(155, 29, 29);

    glBegin(GL_QUADS);

    glVertex2f(-12.07, 0.72);

    glVertex2f(-12.07, 0.48);

    glVertex2f(38.02, 1.52);

    glVertex2f(38, 1.70);

    glEnd();

    glColor3ub(0, 0, 0);

    glBegin(GL_QUADS);

    glVertex2f(-8, 2.08);

    glVertex2f(-7.64, 2.08);

    glVertex2f(-7.63, 0.63);

    glVertex2f(-8, 0.62);

    glEnd();

    glColor3ub(0, 0, 0);

    glBegin(GL_QUADS);

    glVertex2f(0.97, 2.31);

    glVertex2f(1.28, 2.27);

    glVertex2f(1.34, 0.76);

    glVertex2f(0.97, 0.75);

    glEnd();

    glColor3ub(0, 0, 0);

    glBegin(GL_QUADS);

    glVertex2f(11.98, 2.48);

    glVertex2f(12.48, 2.49);

    glVertex2f(12.5, 1);

    glVertex2f(11.98, 0.98);

    glEnd();

    glColor3ub(0, 0, 0);

    glBegin(GL_QUADS);

    glVertex2f(25.45, 2.75);

    glVertex2f(26.09, 2.76);

    glVertex2f(26.09, 1.27);

    glVertex2f(25.45, 1.26);

    glEnd();

    glColor3ub(0, 0, 0);

    glBegin(GL_QUADS);

    glVertex2f(33.99, 2.92);

    glVertex2f(34.48, 2.93);

    glVertex2f(34.58, 1.45);

    glVertex2f(34.03, 1.44);

    glEnd();

    glColor3ub(0, 0, 0);

    glBegin(GL_QUADS);

    glVertex2f(18.39, 2.69);

    glVertex2f(19.16, 2.62);

    glVertex2f(19.18, 1.13);

    glVertex2f(18.42, 1.11);

    glEnd();

    ///boat-1 speed left to right

    glPushMatrix();

    glTranslatef(moveB1, 0.0f, 0.0f);

    glBegin(GL_QUADS);

    glColor3ub(139,69,19);

    glVertex2f(1.0f, -14.0f);

    glVertex2f(1.50f, -13.0f);

    glVertex2f(-2.0f, -13.0f);

    glVertex2f(-3.0f, -14.0f);

    glEnd();

    glBegin(GL_QUADS);

    glColor3ub(0,0,0);

    glVertex2f(2.0f, -14.5f);

    glVertex2f(2.0f, -14.0f);

    glVertex2f(-3.0f, -14.0f);

    glVertex2f(-3.0f, -14.5f);

    glEnd();

    glBegin(GL_TRIANGLES);

    glColor3ub(0,0,0);

    glVertex2f(-3.0f, -14.5f);

    glVertex2f(-3.0f, -14.0f);

    glVertex2f(-4.5f, -13.7f);

    glEnd();

    glBegin(GL_TRIANGLES);

    glColor3ub(0,0,0);

    glVertex2f(2.0f, -14.5f);

    glVertex2f(3.5f, -13.7f);

    glVertex2f(2.0f, -14.0f);

    glEnd();

    glBegin(GL_TRIANGLES);

    glColor3ub(0,0,0);

    glVertex2f(2.0f, -14.0f);

    glVertex2f(1.5f, -13.0f);

    glVertex2f(1.0f, -14.0f);

    glEnd();

    glPopMatrix();

    ///boat-2 motion right to left

    glPushMatrix();

    glTranslatef(moveB2, 0.0f, 0.0f);

    glBegin(GL_QUADS);

    glColor3ub(139,69,19);

    glVertex2f(22.0f, -17.5f);

    glVertex2f(21.0f, -16.5f);

    glVertex2f(17.50f, -16.5f);

    glVertex2f(18.0f, -17.5f);

    glEnd();

    glBegin(GL_QUADS);

    glColor3ub(0,0,0);

    glVertex2f(22.0f, -18.0f);

    glVertex2f(22.0f, -17.5f);

    glVertex2f(17.0f, -17.5f);

    glVertex2f(17.0f, -18.0f);

    glEnd();

    glBegin(GL_QUADS);

    glColor3ub(255,99,71);

    glVertex2f(20.5f, -16.5f);

    glVertex2f(21.0f, -14.5f);

    glVertex2f(18.5f, -14.5f);

    glVertex2f(18.0f, -16.5f);

    glEnd();

    glBegin(GL_QUADS);

    glColor3ub(139,69,19);

    glVertex2f(19.8f, -14.5f);

    glVertex2f(19.8f, -14.0f);

    glVertex2f(19.7f, -14.0f);

    glVertex2f(19.7f, -14.5f);

    glEnd();

    glBegin(GL_TRIANGLES);

    glColor3ub(0,0,0);

    glVertex2f(17.0f, -18.0f);

    glVertex2f(17.0f, -17.5f);

    glVertex2f(15.5f, -17.2f);

    glEnd();

    glBegin(GL_TRIANGLES);

    glColor3ub(0,0,0);

    glVertex2f(22.0f, -17.5f);

    glVertex2f(22.0f, -18.0f);

    glVertex2f(23.5f, -17.2f);

    glEnd();

    glBegin(GL_TRIANGLES);

    glColor3ub(0,0,0);

    glVertex2f(17.0f, -17.5f);

    glVertex2f(18.0f, -17.5f);

    glVertex2f(17.5f, -16.5f);

    glEnd();

    glPopMatrix();

    //end

    glPopMatrix();

    glutSwapBuffers();

}

void updateC(int value)

{

    if(moveC > +36)

    {

        moveC = -38;

    }

    moveC += 0.15;

    glutTimerFunc(20, updateC, 0);

    glutPostRedisplay();

}

void updateB1(int value)

{

    moveB1 += speed;

    if(moveB1 > 38)

    {

        moveB1 = -38;

    }

//   moveB1 += 0.17;

    glutTimerFunc(20, updateB1, 0); //Notify GLUT to call update again in 25 milliseconds

    glutPostRedisplay();

}

void updateB2(int value)

{

    if(moveB2 < -36)

    {

        moveB2 = +38;

    }

    //Notify GLUT that the display has changed

    moveB2 -= 0.13;

    glutTimerFunc(20, updateB2, 0); //Notify GLUT to call update again in 25 milliseconds

    glutPostRedisplay();

}

void handleKeypress(unsigned char key, int x, int y)

{

    switch (key)

    {

    case 's'://stops

        speed = 0.0f;

        break;

    case 'r'://runs

        speed = 0.02f;

        break;

        glutPostRedisplay();

    }

}

void handleMouse(int button, int state, int x, int y)

{

    if (button == GLUT_LEFT_BUTTON)

    {

        speed += 0.05f;

    }

    else if (button == GLUT_RIGHT_BUTTON)

    {

        speed -= 0.05f;

    }

    glutPostRedisplay();

}

void display(void)

{

    DrawAllComponents();

    glFlush ();

}

void init()

{

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

}

int main(int argc, char** argv)

{

    glutInit(&argc, argv);

    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);

    glutInitWindowSize(1300, 700);

    glutInitWindowPosition(100,100);

    glutCreateWindow(" Village Scenery ");

    init();

    glutTimerFunc(100, updateC, 1);    // cloud speed

    glutTimerFunc(100, updateB1, 0); //Boat 1

    glutTimerFunc(100, updateB2, 0); //boat 2

    glutKeyboardFunc(handleKeypress);

    glutMouseFunc(handleMouse);

    glutDisplayFunc(display);

    glutMainLoop();

    return 0;

}