ASSIGNMENT NO : 08

(Mini Project)

Title :
Implementation of openGL functions in mini project.

Aim :
Design and implement game / animation clip / Graphics Editor using open source

graphics library. Make use of maximum features of Object Oriented Programming.

CO Mapped : CO 4, Co 5

Pre-requisite :
1. Basic programming skills of C++ and OpenGL

2. 64-bit Open source Linux

3. Open Source C++ Programming tool like G++/GCC, OpenGL

Learning Objective : To implement OpenGL functions.

Theory:
OpenGL Basics:

Open Graphics Library (OpenGL) is a cross-language (language independent), cross-

platform (platform independent) API for rendering 2D and 3D Vector Graphics (use of

polygons to represent image). OpenGL is a low-level, widely supported modeling and

rendering software package, available across all platforms. It can be used in a range of

graphics applications, such as games,

CAD design, or modeling. OpenGL API is designed mostly in hardware.

Design:
This API is defined as a set of functions which may be called by the client program.
Although functions are similar to those of C language but it is language independent.

Development:
It is an evolving API and Khronos Group regularly releases its new version having some

extended feature compare to previous one. GPU vendors may also provide some additional

functionality in the form of extension.

Associated Libraries:
The earliest version is released with a companion library called

OpenGL utility library. But since OpenGL is quite a complex process. So in order to make it

easier other library such as OpenGL Utility Toolkit is added which is later superseded by

freeglut. Later included library were GLEE, GLEW and glbinding.

Implementation:
Mesa 3D is an open source implementation of OpenGL. It can do pure software

rendering and it may also use hardware acceleration on BSD, Linux, and other platforms

by taking advantage of Direct Rendering Infrastructure.

Installation of OpenGL on Ubuntu

We need the following sets of libraries in programming OpenGL: 1.

Core OpenGL (GL):

consists of hundreds of functions, which begin with a prefix "gl"

(e.g., glColor, glVertex, glTranslate, glRotate). The Core OpenGL models an object via a set of

geometric primitives, such as point, line, and polygon. 2.

OpenGL Utility Library (GLU):

built on-top of the core OpenGL to provide important utilities and more building models

(such as qradric surfaces). GLU functions start with a prefix "glu" (e.g., gluLookAt,

gluPerspective)3.
OpenGL Utilities Toolkit (GLUT):
provides support to interact with the Operating System

(such as creating a window, handling key and mouse inputs); and more building models
(such as sphere and torus). GLUT functions start with a prefix of

"glut"

(e.g., glutCreatewindow, glutMouseFunc). GLUT is designed for constructing small to

medium sudo apt-get install freeglut3-dev

For working on Ubuntu operating system:

gcc filename.c -lGL -lGLU -lglut where filename.c is the name of the file

with which this program is saved.

Prerequisites for OpenGL

Since OpenGL is a graphics API and not a platform of its own, it requires a language to

operate in and the language of choice is C++.

Getting started with

OpenGL Overview of an

OpenGL program
• Main

• Open window and configure frame buffer (using GLUT for example)

• Initialize GL states and display (Double buffer, color mode, etc.)

• Loop

• Check for events if window event (resize, unhide, maximize etc.) modify the viewport and

Redraw else if input event (keyboard and mouse etc.) handle the event (such as move the

camera or change the state) and usually draw the scene

Redraw

• Clear the screen (and buffers e.g., z-buffer)

• Change states (if desired)

• Render

• Swap buffers (if double buffer)

OpenGL order of operations

• Construct shapes (geometric descriptions of objects – vertices, edges, polygons etc.)

• Use OpenGL to

• Arrange shape in 3D (using transformations)

• Select your vantage point (and perhaps lights)

• Calculate color and texture properties of each object

• Convert shapes into pixels on screen

OpenGL Syntax
• All functions have the form: gl*

• glVertex3f() – 3 means that this function take three arguments, and f means that the type

of those arguments is float.

• glVertex2i() – 2 means that this function take two arguments, and i means that the type of

those arguments is integer

• All variable types have the form: GL*

• In OpenGL program it is better to use OpenGL variable types (portability)

• Glfloat instead of float

• Glint instead of int

OpenGL states
▪ On/off (e.g., depth buffer test)

▪ glEnable( GLenum ) ▪

glDisable( GLenum )

Examples:
▪ glEnable(GL_DEPTH_TEST);

▪ glDisable(GL_LIGHTING);

• Mode States

• Once the mode is set the effectstays until reset

Examples: glShadeModel(GL_FLAT) or

glShadeModel(GL_SMOOTH) glLightModel(…) etc.

Drawing in 3D
➢ Depth buffer (or z-buffer) allows scene to remove hidden surfaces. Use

➢ glEnable(GL_DEPTH_TEST) to enable it.

➢ glPolygonMode( Face, Mode )

➢ Face: GL_FRONT, GL_BACK, GL_FRONT_AND_BACKMode: GL_LINE,

➢ GL_POINT, GL_FILL

➢ glCullFace( Mode )

➢ Mode: GL_FRONT, GL_BACK, GL_FRONT_AND_BACK

➢ glFrontFace( Vertex_Ordering )

➢ Vertex Ordering: GL_CW or GL_CCW

Viewing transformation
• glMatrixMode ( Mode )

• Mode: GL_MODELVIEW, GL_PROJECTION, or GL_TEXTURE

• glLoadIdentity()

• glTranslate3f(x,y,z)

• glRotate3f(angle,x,y,z)

• glScale3f(x,y,z)
OpenGL provides a consistent interface to the underlying graphics hardware. This
abstraction allows a single program to run a different graphics hardware easily. A program
written with

OpenGL can even be run in software (slowly) on machines with no graphics acceleration.

OpenGL function names always begin with gl, such as glClear(), and they may end with

characters that indicate the types of the parameters, for example glColor3f(GLfloat red,

GLfloat green, GLfloat blue) takes three floating-point color parameters and

glColor4dv(const GLdouble *v) takes a pointer to an array that contains 4 double-precision

floating-point values. OpenGL constants begin with GL, such as GL DEPTH. OpenGL also

uses special names for types that are passed to its functions, such as GLfloat or GLint, the

corresponding C types are compatible, that is float and int respectively. GLU is the OpenGL

utility library. It contains useful functions at a higher level than those provided by OpenGL,

for example, to draw complex shapes or set up cameras. All GLU functions are written on

top of OpenGL. Like OpenGL, GLU function names begin with glu, and constants begin with

GLU. GLUT, the OpenGL Utility Toolkit, provides a system for setting up callbacks for

interacting with the user and functions for dealing with the windowing system. This

abstraction allows a program to run on different operating systems with only a recompile.

Glut follows the convention of prepending function names with glut and constants with

Glut.

Graphics Mode:
Screen is divided into pixels. While working in C programming language,

default output mode is text mode. To draw graphics objects on screen display

mode must be changed from text mode to graphics mode. To change from text

mode to graphics mode, use functions below.

void initgraph(int *graphdriver, int graph mode, char *pathtodriver);

Some of the basic graphic mode functions are

#include<graphics.h>: The header file must be included for every graphics

program

1. void initgraph(int *graphdriver, int graph mode, char *pathtodriver) ;

initgraph() function is used to change from text mode to graphics mode. The

graphics, driver and graphics mode are the parameters to this function,

detectgraph() fiction is used to find out the graphics driver and graphics

mode.

2. void closegraph() ; closegraph() function closes the graphics mode,

deallocates all memory allocated by graphics system and restores the

screen to text mode.

3. putpixel(int x, int y, color) ; putpixel() function is used to draw pixel at

given position(x,y) and with given color.

4. line (int x1.int y1int x2,int y2) ; line function is used to draw a line from

point(x1,y1)-Starting point to point (x2 y2)-Ending point

5. circle (int x, int y, int radius) ;

Circle function is used to draw a circle with canter (x, y) and radius of a circle.

6. rectangle(int left, int top, int right, int bottom) ;

Rectangle function is used to draw a rectangle. Coordinates of left top and right

bottom corner are required to draw the rectangle.

7. ellipse (int x, int y, start angle, end angle, int x radius, int y radius);

Ellipse function is used to draw ellipse with center(x, y) starting angle, end

Angle, radius of x and y axis.

8. onttextxy(int x, int y, "text") ; outtextxy function is used to insert text at

the given position(x,y).

Algorithm :
1. Start

2. Declare all required variable.

3. Initialize the graphics mode

4 . Draw the lines for bonnet and line drawing function.

6. . Draw the circle for left wheel of car using circle function

7. Draw the circle for right wheel of car using circle function

8.draw the line Line left of left wheel using line function

9. draw the line Line left of Line middle of both wheel

10 draw other parts of car and increase the x coordinates of both wheel to run the car.

11. Stop
Assignment No. 8: Car Animation Mini project

Title : Moving Car

Batch: B3

Name: Yasir Patel

Roll No: COSB58

#include<stdio.h>

#include<conio.h>

#include<graphics.h>

#include<dos.h> void

main()
{

int gd=DETECT,gm,i;

clrscr();

initgraph(&gd,&gm,"C:\\TURBOC3\\BGI");

//setbgcolor(RED); //road line(0,347,700,347);

outtextxy(175,150,"); outtextxy(175,170,"*********

MICROPROJECT ***********"); outtextxy(175,190,"Subject :

Computer Graphics "); for (i = 0; i <= 420; i = i + 10)

// Set color of car as red setcolor(RED);

// These lines for bonnet

and // body of car line(0 + i,

300, 210 + i, 300); line(50 + i,

300, 75 + i, 270); line(75 + i,

270, 150 + i, 270); line(150 + i,

270, 165 + i, 300); line(0 + i,

300, 0 + i, 330); line(210 + i,

300, 210 + i, 330); // For left

wheel of car circle(65 + i, 330,

15); circle(65 + i, 330, 2); //

For right wheel of car

circle(145 + i, 330, 15);

circle(145 + i, 330, 2); // Line

left of left wheel line(0 + i,

330, 50 + i, 330);
// Line middle of both wheel

line(80 + i, 330, 130 + i, 330); //

Line right of right wheel

line(210 + i, 330, 160 + i, 330);

delay(100);

// To erase previous drawn car, draw

// the whole car at same position //

but colour using black

setcolour(BLACK);

// Lines for bonnet and body of car

line(0 + i, 300, 210 + i, 300);

line(50 + i, 300, 75 + i, 270);

line(75 + i, 270, 150 + i, 270);

line(150 + i, 270, 165 + i, 300);

line(0 + i, 300, 0 + i, 330); line(210

+ i, 300, 210 + i, 330); // For left

wheel of car circle(65 + i, 330, 15);

circle(65 + i, 330, 2); // For right

wheel of car circle(145 + i, 330,

15); circle(145 + i, 330, 2); // Line

left of left wheel line(0 + i, 330, 50

+ i, 330);

// Line middle of both wheel

line(80 + i, 330, 130 + i, 330); //

Line right of right wheel

line(210 + i, 330, 160 + i, 330);

getch();