AEROPLANE CRASH

Chapter 1

INTRODUCTION

1.1 Computer Graphics

 Graphics provides one of the most natural means of communicating with a computer,
since our highly developed 2D Or 3D pattern-recognition abilities allow us to
perceive and process pictorial data rapidly.

 Computers have become a powerful medium for the rapid and economical production
of pictures.

 Graphics provide a so natural means of communicating with the computer that they
have become widespread.

 Interactive graphics is the most important means of producing pictures since the
invention of photography and television .

 We can make pictures of not only the real world objects but also of abstract objects
such as mathematical surfaces on 4D and of data that have no inherent geometry.

 A computer graphics system is a computer system with all the components of the
general purpose computer system. There are five major elements in system: input
devices, processor, memory, frame buffer, output devices.

Dept.. of CSE,CEC 2010-2011 1

AEROPLANE CRASH

1.2 OpenGL Technology

OpenGL is the premier environment for developing portable, interactive 2D and 3D

graphics applications. Since its introduction in 1992, OpenGL has become the industry's most
widely used and supported 2D and 3D graphics application programming interface (API),
bringing thousands of applications to a wide variety of computer platforms.

OpenGL fosters innovation and speeds application development by incorporating a

broad set of rendering, texture mapping, special effects, and other powerful visualization
functions. Developers can leverage the power of OpenGL across all popular desktop and
workstation platforms, ensuring wide application deployment.
OpenGL Available Everywhere: Supported on all UNIX® workstations, and shipped
standard with every Windows 95/98/2000/NT and MacOS PC, no other graphics API
operates on a wider range of hardware platforms and software environments.
OpenGL runs on every major operating system including Mac OS, OS/2, UNIX,
Windows 95/98, Windows 2000, Windows NT, Linux, Open Step, and BeOS; it also works
with every major windowing system, including Win32, MacOS, Presentation Manager, and
X-Window System. OpenGL is callable from Ada, C, C++, Fortran, Python, Perl and Java
and offers complete independence from network protocols and topologies.
The OpenGL interface
Our application will be designed to access OpenGL directly through functions in three
libraries namely: gl,glu,glut.

Dept.. of CSE,CEC 2010-2011 2

AEROPLANE CRASH

Chapter 2
LITERATURE SURVEY

The basic functions like glcolor3f(…); gltotatef(..),gltranslate(..) etc that are most
commonly used in the code are taken from the prescribed VTU Text book “INTERACTIVE
COMPUTER GRAPHICS” 5th edition by Edward Angel.[1].
The lab programs in the syllabus also serve as a basic template for creating a project. The
usage of colors and specifications are taken from the various programs that were taught in the
lab.[1].
The VTU prescribed text book serves as a huge database of functions and they are used in the
project.
The C++ concepts which are used are being taken from “object oriented programming” by
Sourav Sahay.[2].
Some concepts like constructing bowl and fountain are taken from the search results in
codecolony.com..

Dept.. of CSE,CEC 2010-2011 3

AEROPLANE CRASH

Chapter 3
REQUIREMENTS AND SPECIFICATIONS

3.1 Purpose of the requirements document

The software requirement specification is the official statement of what is required for
development of particular project. It includes both user requirements and system
requirements. This requirement document is utilized by variety of users starting from project
manager who gives project to the engineer responsible for development of project.

It should give details of how to maintain, test, verify and what all the actions to be
carried out through life cycle of project.

Scope of the project

The scope is to use the basic primitives defined in openGL library creating complex
objects. We make use of different concepts such as pushmatrix(),translate()
,popmatrix(),timer function.

Definition

The project DEMOLITION OF A BUILDING BY AEROPLANE CRASH

is created to demonstrate OpenGL’s concepts. It encompasses some of the skills learnt
in our OpenGL classes such as pushmatrix(),translate() ,popmatrix(),timer function
.

Acronyms & Abbreviations

OpenGL provides a powerful but primitive set of rendering command, and all higher
level design must be done in terms of these commands.

OpenGL Utility Toolkit(GLUT):- windows-system-independent toolkit.

Dept.. of CSE,CEC 2010-2011 4

AEROPLANE CRASH

References

OpenGL tutorials

Interactive Computer Graphics(Edward Angel)

3.2 Specific requirements

User Requirement:

 Easy to understand and should be simple.

 The built-in functions should be utilized to maximum extent.

 OpenGL library facilities should be used.

Software Requirements:
 Ubuntu Os.

 Eclipse compiler.

Hardware Requirements:

 Processor- Intel or AMD(Advanced Micro Devices)

 RAM- 512MB(minimum)

 Hard Disk-1MB(minimum)

 Mouse

 Keyboard

 Monitor

Dept.. of CSE,CEC 2010-2011 5

AEROPLANE CRASH

Chapter 4
DESIGN
4.1 User Defined Functions

 myinit():
This function initializes light source for ambient, diffuse and specular types.

 display():
This function creates and translates all the objects in a specified location in a
particular order and also rotates the objects in different axes.

glClear(GL_COLOR_BUFFER_BIT);
glFlush();
 timerfunc():
This function starts a timer in the event loop that delays the event loop for
delay miiliseconds.

 MainLoop():
This function whose execution will cause the program to begin an event
processing loop.

 PushMatrix():
Save the present values of attributes and matrices placing ,or pushing on the
top of the stack.

 PopMatrix():
We can recover them by removing them from stack;

 Translated();
In translate func the variables are components of the displacement vector.

 main():

Dept.. of CSE,CEC 2010-2011 6

AEROPLANE CRASH

The execution of the program starts from this function. It initializes the
graphics system and includes many callback functions.

 PostRedisplay():
It ensures that the display will be drawn only once each time the
program goes through the event loop.

Dept.. of CSE,CEC 2010-2011 7

AEROPLANE CRASH

Chapter 5

IMPLEMENTATION

5.1 FUNCTIONS
GL_LINES -
Treats each pair of vertices as an independent line segment.
Vertices 2n - 1 and 2n define line n. N/2 lines are drawn.
GL_LINE_LOOP -
Draws a connected group of line segments from the first vertex to the last, then back to the
first. Vertices n and n + 1 define line n. The last line, however, is defined by vertices N and N
lines are drawn.

Basic Functions
glPushMatrix, glPopMatrix Function
The glPushMatrix and glPopMatrix functions push and pop the current matrix stack.
SYNTAX: void glPushMatrix();
void glPopMatrix(void);

glBegin, glEnd Function

The glBegin and glEnd functions delimit the vertices of a primitive or a group of like
primitives.
SYNTAX:
void glBegin, glEnd(GLenum mode);
PARAMETERS:
 mode -
The primitive or primitives that will be created from vertices presented between glBegin
and the subsequent glEnd. The following are accepted symbolic constants and their
meanings:

Transformation Functions
Dept.. of CSE,CEC 2010-2011 8
AEROPLANE CRASH

glTranslate Function
The glTranslated and glTranslatef functions multiply the current matrix by a
translation matrix.
SYNTAX:
void glTranslate( x, y, z);
PARAMETERS:
 x, y, z - The x, y, and z coordinates of a translation vector.
Funtions used to display
glMatrixMode Function
The glMatrixMode function specifies which matrix is the current matrix.
SYNTAX:
void glMatrixMode(GLenum mode);
PARAMETERS:
 mode - The matrix stack that is the target for subsequent matrix operations. The mode
parameter can assume one of three values:

Value Meaning
GL_MODELVIEW Applies subsequent matrix operations to the
modelview matrix stack.
glLoadIdentity Function
The glLoadIdentity function replaces the current matrix with the identity matrix.
SYNTAX:
void glLoadIdentity(void);
5.2 FUNCTIONS USED TO SET THE VIEWING VOLUME

glOrtho
This function defines orthographic viewing volume with all parameters measured from the
centre of projection.
multiply the current matrix by a perspective matrix.
SYNTAX:
void glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,
GLdouble near, GLdouble far)

Dept.. of CSE,CEC 2010-2011 9

AEROPLANE CRASH

PARAMETERES:
 left, right -
Specify the coordinates for the left and right vertical clipping planes.
 bottom, top -
Specify the coordinates for the bottom and top horizontal clipping planes.
 nearVal, farVal -
Specify the distances to the nearer and farther depth clipping planes. These values are
negative if the plane is to be behind the viewer.

5.3 CALL BACK FUNCTIONS

glutDisplayFunc Function
glutDisplayFunc sets the display callback for the current window.
SYNTAX:
void glutDisplayFunc(void (*func)(void));

glutReshapeFunc Function
glutReshapeFunc sets the reshape callback for the current window.
SYNTAX:
void glutReshapeFunc(void (*func)(int width, int height));

5.4MAIN FUNCTION
glutInit Function
glutInit is used to initialize the GLUT library.
SYNTAX:
glutInit(int *argcp, char **argv);
PARAMETERS:
 argcp - A pointer to the program's unmodified argc variable from main. Upon return, the
value pointed to by argcp will be updated, because glutInit extracts any command line
options intended for the GLUT library.
 Argv -
The program's unmodified argv variable from main. Like argcp, the data for argv will

Dept.. of CSE,CEC 2010-2011 10

AEROPLANE CRASH

be updated because glutInit extracts any command line options understood by the GLUT
library.
 glutInit(&argc,argv);

glutInitDisplayMode Function
glutInitDisplayMode sets the initial display mode.
SYNTAX:
void glutInitDisplayMode(unsigned int mode);
PARAMETERS:
 mode -
Display mode, normally the bitwise OR-ing of GLUT display mode bit masks. See values
below:
GLUT_RGB: An alias for GLUT_RGBA.
GLUT_DOUBLE:Bit mask to select a double buffered window. This overrides
GLUT_SINGLE.
GLUT_DEPTH: Bit mask to select a window with a depth buffer.

glutMainLoop Function
glutMainLoop enters the GLUT event processing loop.

SYNTAX:
void glutMainLoop(void);

Dept.. of CSE,CEC 2010-2011 11

AEROPLANE CRASH

Chapter 6
SNAP SHOTS

Fig. 6.1

Fig. 6.2

Dept.. of CSE,CEC 2010-2011 12

AEROPLANE CRASH

Dept.. of CSE,CEC 2010-2011 13

AEROPLANE CRASH

APPENDIX

#include<stdio.h>
#include<GL/glut.h>
GLfloat a=0,b=0,c=0,d=0,e=0;
void building();
void building1();
void outline();
void blast();
void road();
void display2();
void display3();
void build_outline();
void update(int value)
{
a+=20.0; //Plane position takeoff on x axis
b-=10.0; //Road Strip backward movement
c+=15; //take off at certain angle on y axis
if(b<=-78.0)// moving of run way
b=0.0;
glutPostRedisplay();
glutTimerFunc(150,update,0);//delay
}
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
road();
glPushMatrix();
glTranslated(a,c,0.0);
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);//rectangular body
glVertex2f(0.0,30.0);
glVertex2f(0.0,55.0);
glVertex2f(135.0,55.0);
glVertex2f(135.0,30.0);
glEnd();
glPopMatrix();

Dept.. of CSE,CEC 2010-2011 14

AEROPLANE CRASH

glPushMatrix();
glTranslated(a,c,0.0);
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);//upper triangle construction plane
glVertex2f(135.0,55.0);
glVertex2f(150.0,50.0);
glVertex2f(155.0,45.0);
glVertex2f(160.0,40.0);
glVertex2f(135.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(a,c,0.0);
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP);//outline of upper triangle plane
glVertex2f(135.0,55.0);
glVertex2f(150.0,50.0);
glVertex2f(155.0,45.0);
glVertex2f(160.0,40.0);
glVertex2f(135.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(a,c,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);//lower triangle
glVertex2f(135.0,40.0);
glVertex2f(160.0,40.0);
glVertex2f(160.0,37.0);
glVertex2f(145.0,30.0);
glVertex2f(135.0,30.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(a,c,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);//back wing
glVertex2f(0.0,55.0);
glVertex2f(0.0,80.0);
glVertex2f(10.0,80.0);

Dept.. of CSE,CEC 2010-2011 15

AEROPLANE CRASH

glVertex2f(40.0,55.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(a,c,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);//left side wing
glVertex2f(65.0,55.0);
glVertex2f(50.0,70.0);
glVertex2f(75.0,70.0);
glVertex2f(90.0,55.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(a,c,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);//rightside wing
glVertex2f(70.0,40.0);
glVertex2f(100.0,40.0);
glVertex2f(80.0,15.0);
glVertex2f(50.0,15.0);

glEnd();
glPopMatrix();
if(c>360) //timer to jump to next display
{
display2();
d+=20;//plane takeoff on x in 2nd display
}
if(a>500.0)//window position during take off
{
a=0.0;
b=0.0;
}
if(c>750)//timer to jump to 3rd display
{
display3();
e+=20;//plane takeoff on x in 3rd display
if(e>250)//timer to call blast function
{
blast();

Dept.. of CSE,CEC 2010-2011 16

AEROPLANE CRASH

e=250;
}
}
glFlush();
}
void building()
{
glColor3f(0.60,0.40,0.70);
glBegin(GL_POLYGON);
glVertex2f(350.0,80.0);
glVertex2f(350.0,480.0);
glVertex2f(400.0,400.0);
glVertex2f(400.0,0.0);
glEnd();
glColor3f(0.75,0.75,0.75);
glBegin(GL_POLYGON);
glVertex2f(400.0,0.0);
glVertex2f(400.0,400.0);
glVertex2f(450.0,400.0);
glVertex2f(450.0,0.0);
glEnd();
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(400.0,400.0);
glVertex2f(350.0,480.0);
glVertex2f(400.0,480.0);
glVertex2f(450.0,400.0);
glEnd();
glColor3f(0.60,0.40,0.70);
glBegin(GL_POLYGON);//upper triangle of building
glVertex2f(400.0,400.0);
glVertex2f(350.0,480.0);
glVertex2f(400.0,480.0);
glEnd();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINES);//seperation line of floors
glVertex2f(350.0,180);
glVertex2f(400.0,100);
glEnd();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINES);

Dept.. of CSE,CEC 2010-2011 17

AEROPLANE CRASH

glVertex2f(350.0,280);
glVertex2f(400.0,200);
glEnd();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINES);
glVertex2f(350.0,380);
glVertex2f(400.0,300);
glEnd();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINES);
glVertex2f(450.0,100);
glVertex2f(400.0,100);
glEnd();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINES);
glVertex2f(450.0,200);
glVertex2f(400.0,200);
glEnd();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINES);
glVertex2f(450.0,300);
glVertex2f(400.0,300);
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINES);
glVertex2f(350.0,180);
glEnd();
build_outline();
}
void build_outline()//building out lines
{
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP);
glVertex2f(350.0,80.0);
glVertex2f(350.0,480.0);
glVertex2f(400.0,400.0);
glVertex2f(400.0,0.0);
glEnd();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP);
glVertex2f(400.0,0.0);
glVertex2f(400.0,400.0);

Dept.. of CSE,CEC 2010-2011 18

AEROPLANE CRASH

glVertex2f(450.0,400.0);
glVertex2f(450.0,0.0);
glEnd();
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP);
glVertex2f(400.0,400.0);
glVertex2f(350.0,480.0);
glVertex2f(400.0,480.0);
glVertex2f(450.0,400.0);
glEnd();
}
void blast(void)//blast polygon construction
{
glPushMatrix();
glTranslated(-10.0,-60.0,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(404.4,320.0);
glVertex2f(384.0,285.0);
glVertex2f(368.0,344.5);
glVertex2f(344.0,355.0);
glVertex2f(347.2,414.5);
glVertex2f(332.8,442.5);
glVertex2f(347.2,477.5);
glVertex2f(352.0,530.0);
glVertex2f(379.2,519.5);
glVertex2f(396.8,565.0);
glVertex2f(416.0,530.0);
glVertex2f(440.0,547.5);
glVertex2f(452.8,512.5);
glVertex2f(472.0,512.5);
glVertex2f(475.2,470.5);
glVertex2f(488.0,442.5);
glVertex2f(488.0,404.0);
glVertex2f(470.0,372.5);
glVertex2f(475.2,337.5);
glVertex2f(464.0,306.0);
glVertex2f(444.8,320.0);
glVertex2f(425.6,285.0);
glVertex2f(404.8,320.0);
glEnd();

Dept.. of CSE,CEC 2010-2011 19

AEROPLANE CRASH

glPopMatrix();
}
void road()
{
glColor3f(0.0,0.0,0.0);
glBegin(GL_POLYGON);//black road
glVertex2f(0.0,0.0);
glVertex2f(0.0,100.0);
glVertex2f(500.0,100.0);
glVertex2f(500.0,0.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(b,0.0,0.0);
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);//white strips on road
glVertex2f(0.0,40.0);
glVertex2f(8.0,60.0);
glVertex2f(58.0,60.0);
glVertex2f(50.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(b,0.0,0.0);
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(100.0,40.0);
glVertex2f(108.0,60.0);
glVertex2f(158.0,60.0);
glVertex2f(150.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(b,0.0,0.0);
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(200.0,40.0);
glVertex2f(208.0,60.0);
glVertex2f(258.0,60.0);
glVertex2f(250.0,40.0);
glEnd();

Dept.. of CSE,CEC 2010-2011 20

AEROPLANE CRASH

glPopMatrix();
glPushMatrix();
glTranslated(b,0.0,0.0);
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(300.0,40.0);
glVertex2f(308.0,60.0);
glVertex2f(358.0,60.0);
glVertex2f(350.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(b,0.0,0.0);
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(400.0,40.0);
glVertex2f(408.0,60.0);
glVertex2f(458.0,60.0);
glVertex2f(450.0,40.0);
glEnd();
glPopMatrix();
}
void display2()
{
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glTranslated(d,300.0,0.0);
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(0.0,30.0);
glVertex2f(0.0,55.0);
glVertex2f(135.0,55.0);
glVertex2f(135.0,30.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(d,300.0,0.0);
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(135.0,55.0);
glVertex2f(150.0,50.0);

Dept.. of CSE,CEC 2010-2011 21

AEROPLANE CRASH

glVertex2f(155.0,45.0);
glVertex2f(160.0,40.0);
glVertex2f(135.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(d,300.0,0.0);
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP);
glVertex2f(135.0,55.0);
glVertex2f(150.0,50.0);
glVertex2f(155.0,45.0);
glVertex2f(160.0,40.0);
glVertex2f(135.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(d,300.0,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(135.0,40.0);
glVertex2f(160.0,40.0);
glVertex2f(160.0,37.0);
glVertex2f(145.0,30.0);
glVertex2f(135.0,30.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(d,300.0,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(0.0,55.0);
glVertex2f(0.0,80.0);
glVertex2f(10.0,80.0);
glVertex2f(40.0,55.0);
//glVertex2f(165.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(d,300.0,0.0);
glColor3f(1.0,0.0,0.0);

Dept.. of CSE,CEC 2010-2011 22

AEROPLANE CRASH

glBegin(GL_POLYGON);
glVertex2f(65.0,55.0);
glVertex2f(50.0,70.0);
glVertex2f(75.0,70.0);
glVertex2f(90.0,55.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(d,300.0,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(70.0,40.0);
glVertex2f(100.0,40.0);
glVertex2f(80.0,15.0);
glVertex2f(50.0,15.0);
glEnd();
glPopMatrix();
}
void display3()
{
glClear(GL_COLOR_BUFFER_BIT);
building();
glPushMatrix();
glTranslated(e,300.0,0.0);
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(0.0,30.0);
glVertex2f(0.0,55.0);
glVertex2f(135.0,55.0);
glVertex2f(135.0,30.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(e,300.0,0.0);
glColor3f(1.0,1.0,1.0);
glBegin(GL_POLYGON);
glVertex2f(135.0,55.0);
glVertex2f(150.0,50.0);
glVertex2f(155.0,45.0);
glVertex2f(160.0,40.0);
glVertex2f(135.0,40.0);

Dept.. of CSE,CEC 2010-2011 23

AEROPLANE CRASH

glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(e,300.0,0.0);
glColor3f(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP);
glVertex2f(135.0,55.0);
glVertex2f(150.0,50.0);
glVertex2f(155.0,45.0);
glVertex2f(160.0,40.0);
glVertex2f(135.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(e,300.0,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(135.0,40.0);
glVertex2f(160.0,40.0);
glVertex2f(160.0,37.0);
glVertex2f(145.0,30.0);
glVertex2f(135.0,30.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(e,300.0,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(0.0,55.0);
glVertex2f(0.0,80.0);
glVertex2f(10.0,80.0);
glVertex2f(40.0,55.0);
//glVertex2f(165.0,40.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(e,300.0,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(65.0,55.0);
glVertex2f(50.0,70.0);

Dept.. of CSE,CEC 2010-2011 24

AEROPLANE CRASH

glVertex2f(75.0,70.0);
glVertex2f(90.0,55.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(e,300.0,0.0);
glColor3f(1.0,0.0,0.0);
glBegin(GL_POLYGON);
glVertex2f(70.0,40.0);
glVertex2f(100.0,40.0);
glVertex2f(80.0,15.0);
glVertex2f(50.0,15.0);
glEnd();
glPopMatrix();
}
void myinit()
{
glClearColor(0.0f,0.0f,1.0f,0.0f);
glColor3f(1.0,0.0,0.0);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,499.0,0.0,499.0);
}
void main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(500.0,500.0);
glutInitWindowPosition(0,0);
glutCreateWindow("AERO");
glutDisplayFunc(display);
myinit();
glutTimerFunc(100,update,0);
glutMainLoop();
}

Dept.. of CSE,CEC 2010-2011 25

AEROPLANE CRASH

BIBLIOGRAPHY

1) OpenGL Programming Guide (Addison-Wesley Publishing Company)

2) The OpenGL Utility Toolkit (GLUT)Programming Interface
-API Version 3 BY MARK J. KILGARD
3) Interactive computer graphics
-A top down approach by using Open GL by EDWARD ANGEL

Dept.. of CSE,CEC 2010-2011 26