6th sem project on heli dept. report
Post on 19-Apr-2017
219 Views
Preview:
TRANSCRIPT
VISVESVARAYA TECHNOLOGICAL UNIVERSITYBELGAUM
A Project report on
A TrainSubmitted in partial fulfillment for the award of the degree in
Bachelor of EngineeringIn
COMPUTER SCIENCE & ENGINEERING
By
Ranjeet Singh 1NC11CS069
Under the guidance ofMrs. ManjhusaMs Prabha Naik
Assistant ProfessorsCSE Department.
COLLEGE OF ENGINEERING AND TECHNOLOGYVENKATAGIRI KOTE, DEVANAHALLI, BENGALURU – 562110
Department of Computer Science Engineering
COLLEGE OF ENGINEERINGAND TECHNOLOGY
CERTICIFICATE
This is to certify that the project work entitled “A Train” is carried out by Mr. Ranjeet
Singh, USN 1NC11CS069 a are the bonafied students of Nagarjuna College of Engineering
and Technology in partial fulfillment for the award of Bachelor of Engineering in VI semester
Computer Science & Engineering of Visvesvaraya Technological University, Belgaum during
the year 2014.
Name & Signature of the Guide Name & Signature of the HOD
Mrs Manjhusa Dr. Shantakumar B.Patil
External ExaminerName of the External Examiners Signature with Date:-
1.
2.
1 | P a g e
ACKNOWLEDGEMENT
We would like to take this opportunity to thank all the people who have helped us to successfully
complete this mini project.
I am very thankful to the principal, Dr. S. G. Gopalakrishna, NCET, Bangalore, for being kind
enough to provide me an opportunity to work on a project in this institution.
First and foremost we would like to thank Dr. Shantakumar B. Patil, HOD of computer
Science Department for providing excellent lab facilities and for his in valuable advice that
helped us in completing our project on time.
We would also like to acknowledge the effort put in by our lecturer Mrs. Manjhusa,Ms
Prabha Naik in helping us understand the relevant concepts related to assemblers and for
providing guidance whenever necessary.
We are also highly indebted to the lab administrator who acceded to our requests whenever we
required lab facilities to work on our project as well as all our friends who helped us in testing
and debugging our project.
Ranjeet Singh (1NC11CS069)
2 | P a g e
ABSTRACT
Creating a Train in Computer graphics is not that much hard but logical. we are going to see an OpenGL Projects on trains. Our objective is to implement cg projects for running train. Here we implementthe following things - 1.Train - the bogies and the engine2. Train Tracks3. Sky 4. Mouse/keyboard for motionOur next aim would be to give motion to the train. As we are going to implement a simple train so our track will be a straight not in zigzag manner.Design and ImplementationFor developing the train - it's bogies and engine we have defined a simple function. In this simple OpenGL projects we are coding this function so we can make any no trains, by just calling it.Software Requirements:
An MS-DOS based operating system like Windows 98, Windows 2000 or
Windows XP the platform required to develop the 2D and 2D graphics
applications.
A Visual C/C++ compiler is required for compiling the source code to make the
executable file which can then be directly executed.
A built in graphics library like glut and glut32, and header file like glut.h and also
dynamic link libraries like glut and glut32 are required for creating the 2D layout.
Hardware Requirements:
The hardware requirements are very minimal and the software can run on most of the machines.
Processor - Intel 486/Pentium processor or above.
Processor Speed - 500 MHz or above
RAM - 64MB or above Storage Space - 2 MB or above
Monitor resolution - A color monitor with a minimum resolution of 640*480
Table of Contents
3 | P a g e
Certificate Acknowledgement
AbstractChapter 1 Introduction……………………………………
1.1-About OpenGl…………………………………... 1.1-Train Rendering in OpenGl ………………. Chapter 2 – System Analysis……………………………...
2.1 -Scope of the Project…………………………… 2.2- Aim of the Project………………………………
Chapter 3 -Requirement Specifications …………………... 3.1- Software Requirement………………………….
Chapter 4 – Design Phase…………………………………. 4.1- Introduction………………………………… 4.2- Model Description …………………………
Chapter 5-Code……………………………………………. 5.1- Animations.cpp……………………………….. 5.2- Cloud.cpp………………………………………… 5.3-Ground.cpp ……………………………………….. 5.4-Train.cpp ……………………………………. 5.5- Main.cpp…………………………………………..
SnapShots …………………………………………………. Conclusion………………………………………………… Bibliography ………………………………………………
1.INTRODUCTION
4 | P a g e
The dominant characteristic of this new millennium is how computer and communication
technologies have become dominant forces in our life. Activities as wide –ranging as
filmmaking, publishing, banking, and education continue to undergo revolutionary changes as
these technologies alter the ways in which we conduct our daily activities. The combination of
computers, networks, and the complex visual systems, through computer graphics, has led to
new ways of displaying information, seeing virtual worlds and communicating with people and
machines.
Computer graphics is concerned with all aspects of producing pictures or images using a
computer. The field began humbly almost 50 years ago, with a display of few lines on a cathode-
ray-tube; now, we can create images by computer that are indistinguishable from photographs of
real objects. We routinely train pilots with simulated airplanes, generating graphical displays of a
virtual environment of real time. Feature –length movies made entirely by computer have been
successful, both critically and financially. Massive multiplayer games can involve tens of
thousands of concurrent participants.
GLUT:
It is a complete API written by Mark Kilgard, which lets us create windows and handle the
messages. It exists for several platforms that mean that a program, which uses GLUT, can be
compiled on many platforms without any changes in the code.
ADDITIONAL LIBRARIES
There are two libraries that we have that came with OpenGL:
5 | P a g e
1: glu:It is a set of utility functions. They are easy way of doing things that is tedious with raw
OpenGL
2: glx:It allows you to open up X window and link it up with OpenGL so that it will draw to that
window.
HOW OpenGL WORKS?
To be hardware independent OpenGL provides its own data types. They all begin with
“GL”. Example: GLfloat, Glint.
There are also many symbolic constants that all begin with “GL_”Example:
GL_POINTS,GL_POLYGON.
Finally commands have prefix “gl”. Example: glVertex3f.
There is a utility library called “GLU”. Here the prefixes are”GLU_”,”glu”. GLUT
commands begin with “glut”. It is the same for every library
OpenGL is a widely accepted standard for developing graphics applications. Fortunately,
OpenGL is easy to learn and it possesses most of the characteristics of other graphics systems.
Graphics API’s, such as OpenGL, developed as a way to provide application programmers with
access to hardware features that were being provided by latest graphics hardware.
1.1 APPLICATIONS OF COMPUTER GRAPHICS
The development of computer graphics has been driven both by the needs of the user
community and by advances in hardware and software. The applications of computer graphics
are many and varied; we can divide them into four major areas:
1. Display of information
2. Design
3. Simulation and animation
4. User interfaces
1.1.1. DISPLAY OF INFORMATION
6 | P a g e
Medical imaging posses interesting and important data analysis problems. Modern
imaging technologies such as computed tomography (CT), magnetic resonance imaging (MRI),
ultrasound and positron emission tomography (PET)-generate 2D data that must be subjected to
algorithmic manipulation to provide useful information.
The field of scientific visualization provides graphical tools that help the researchers
interpret the fast quantity of data that they generate.
1.1.2. DESIGN
Professions such as engineering and architectures are concerned with design. Starting with a set
of specifications, engineers and architects seek a cost effective and esthetic solution that satisfies
the specifications.
Design is an interactive process. Design problem are either over determined such that
they posses no solution that satisfies all the criteria, much less an optimal solution, or
underdetermined, such that they have multiple solutions that satisfy the design criteria.
1.1.3. SIMULATION AND ANIMATION
Graphic system evolved to be capable of generating sophisticated images in real time,
engineers and researchers began to use them as simulators. One of the most important uses has
been in the training of pilots. The use of special PLSI chips has led to a generation of arcade,
games as sophisticated as flight simulators.
The simulator can be used for designing the robot, planning its path, and simulating its
behavior in complex environment. The success of flight simulators led to the use of computer
graphics for animation in the TV, motion picture and advertising industries. Entire animated
7 | P a g e
movies can now be made by computers at a cost less than that of movies made with tradition
hand animation techniques
The graphic technology for games, both in the form of the graphics processing units that
are on graphics cards in personal computers and in game boxes such as the Xbox and the play
stations, is being used for simulation rather than expensive specialized hardware.
1.1.4. USER INTERFACES
Our interaction with computers has become dominated by a visual paradigm that includes
windows, icons, menus and a pointing device such as a mouse. From users perspective, winding
system such as the X window system, Microsoft windows, and the Macintosh Os x defer only in
derails.
2. INTRODUCTION TO OpenGL
What is OpenGL?
Graphics rendering API.
8 | P a g e
High-quality color images composed of geometric primitives.
Operating system independent.
OpenGL is an application programmer’s interface (API) that allows
programmers to write programs that access graphics hardware.
OpenGL provides a set of commands to render a three dimensional scene. That means
you provide the data in an OpenGL-useable form and OpenGL will show this data on the screen
(render it). It is developed by many companies and it is free to use. You can develop OpenGL-
applications without licensing.
OpenGL bases on the state variables. There are many values, for example the color, that
remain after being specified. That means, you can specify a color once and draw several
polygons, lines or whatever with this color then. There are no classes like in DirectX. However,
it is logically structured. Before we come to the commands themselves, here is another thing:
To be hardware independent, OpenGL provides its own data types. They all begin with
"GL". For example GLfloat, GLint and so on. There are also many symbolic constants, they all
begin with "GL_", like GL_POINTS, GL_POLYGON. Finally the commands have the prefix
"gl" like h. There is a utility library called GLU, here the prefixes are "GLU_" and "glu". GLUT
commands begin with "glut", it is the same for every library. You want to know which libraries
coexist with the ones called before. There are libraries for every system, Windows has the wgl*-
Functions, UNIX systems glx* and so on.
A very important thing is to know, that there are two important matrices, which affect the
transformation from the 2D-world to the 2d-screen: The projection matrix and the modelview
matrix. The projection matrix contains information, how a vertex – let's say a "point" in space –
shall be mapped to the screen. This contains, whether the projection shall be isometric or from a
perspective, how wide the field of view is and so on. Into the other matrix you put information,
how the objects are moved, where the viewer is and so on.
2.1 The OpenGL pipeline:
9 | P a g e
Fig 1.0 The OpenGL rendering pipeline.
Commands may either be accumulated in display lists, or processed immediately through
the pipeline. Display lists allow for greater optimization and command reuse, but not all
commands can be put in display lists.
The first stage in the pipeline is the evaluator. This stage effectively takes any polynomial
evaluator commands and evaluates them into their corresponding vertex and attributes
commands.
The second stage is the per-vertex operations, including transformations, lighting,
primitive assembly, clipping, projection, and viewport mapping.
The third stage is rasterization. This stage produces fragments, which are series of frame
buffer addresses and values, from the viewport-mapped primitives as well as bitmaps and pixel
rectangles.
The fourth stage is the per-fragment operations. Before fragments go to the frame buffer,
they may be subjected to a series of conditional tests and modifications, such as blending or z-
buffering.
10 | P a g e
2.2 Vertices and Primitives
Most objects use Begin/End primitives. Each Begin/End primitive contains a series of
vertex data, and may optionally contain normals, texture coordinates, colors, edge flags, and
material properties.
There are ten primitive types, as follows:
Points individual points
Linespairs of vertices interpreted as individual line
segments
Polygon boundary of a simple, convex polygon
Triangles triples of vertices interpreted as triangles
Quadsquadruples of vertices interpreted as four-sided
polygons
11 | P a g e
Line Strip series of connected line segments
Line Loopsame as above, with a segment added between last
and first vertices
Triangle Strip linked strip of triangles
Triangle Fan linked fan of triangles
Quad Strip linked strip of quadrilaterals
2. PROGRAM DEFINITION
What is the difference between transparent, translucent, and blended primitives?
A transparent physical material shows objects behind it as unobscured and doesn't reflect
light off its surface. Clear glass is a nearly transparent material. Although glass allows most light
12 | P a g e
to pass through unobscured, in reality it also reflects some light. A perfectly transparent material
is completely invisible.
A translucent physical material shows objects behind it, but those objects are obscured by the
translucent material. In addition, a translucent material reflects some of the light that hits it,
making the material visible. Physical examples of translucent materials include sheer cloth, thin
plastic, and smoked glass.
Transparent and translucent are often used synonymously. Materials that are neither
transparent nor translucent are opaque.
Blending is OpenGL's mechanism for combining color already in the frame buffer with
the color of the incoming primitive. The result of this combination is then stored back in the
frame buffer. Blending is frequently used to simulate translucent physical materials. One
example is rendering the smoked glass windshield of a car. The driver and interior are still
visible, but they are obscured by the dark color of the smoked glass.
How can I achieve a transparent effect?
glEnable (GL_BLEND); glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
After blending is enabled, as shown above, the incoming primitive color is blended with
the color already stored in the frame buffer. glBlendFunc() controls how this blending occurs.
The typical use described above modifies the incoming color by its associated alpha value and
modifies the destination color by one minus the incoming alpha value. The sum of these two
colors is then written back into the framebuffer.
The primitive’s opacity is specified using glColor4*(). RGB specifies the color, and the
alpha parameter specifies the opacity.
13 | P a g e
When using depth buffering in an application, you need to be careful about the order in
which you render primitives. Fully opaque primitives need to be rendered first, followed by
partially opaque primitives in back-to-front order. If you don't render primitives in this order, the
primitives, which would otherwise be visible through a partially opaque primitive, might lose the
depth test entirely.
How can I create screen door transparency?
This is accomplished by specifying a polygon stipple pattern with glPolygonStipple() and
by rendering the transparent primitive with polygon stippling enabled
(glEnable(GL_POLYGON_STIPPLE)). The number of bits set in the stipple pattern determine
the amount of translucency and opacity; setting more bits result in a more opaque object, and
setting fewer bits results in a more translucent object. Screendoor transparency is sometimes
preferable to blending, becuase it's order independent (primitives don't need to be rendered in
back-to-front order).
How can I render glass with OpenGL?
This question is difficult to answer, because what looks like glass to one person might not
to another. What follows is a general algorithm to get you started.
First render all opaque objects in your scene. Disable lighting, enable blending, and
render your glass geometry with a small alpha value. This should result in a faint rendering of
your object in the frame buffer. (Note: You may need to sort your glass geometry, so it's
rendered in back to front Z order.)
Now, you need to add the specular highlight. Set your ambient and diffuse material colors
to black, and your specular material and light colors to white. Enable lighting. Set
glDepthFunc(GL_EQUAL), then render your glass object a second time.
14 | P a g e
Do I need to render my primitives from back to front for correct rendering of translucent
primitives to occur?
If your hardware supports destination alpha, you can experiment with different
glBlendFunc() settings that use destination alpha. However, this won't solve all the problems
with depth buffered translucent surfaces. The only sure way to achieve visually correct results is
to sort and render your primitives from back to front.
I want to use blending but cannot get destination alpha to work. Can I blend or create a
transparency effect without destination alpha?
Many OpenGL devices don't support destination alpha. In particular, the OpenGL 1.1
software rendering libraries from Microsoft don't support it. The OpenGL specification doesn't
require it.
If you have a system that supports destination alpha, using it is a simple matter of asking
for it when you create your window. For example, pass GLUT_ALPHA to
glutInitDisplayMode(), then set up a blending function that uses destination alpha, such as:
glBlendFunc(GL_ONE_MINUS_DST_ALPHA,GL_DST_ALPHA);
Often this question is asked under the mistaken assumption that destination alpha is
required to do blending. It's not. You can use blending in many ways to obtain a transparency
effect that uses source alpha instead of destination alpha. The fact that you might be on a
platform without destination alpha shouldn't prevent you from obtaining a transparency effect.
See the OpenGL Programming Guide chapter 6 for ways to use blending to achieve
transparency.
If I draw a translucent primitive and draw another primitive behind it, I expect the second
primitive to show through the first, but it's not there?
15 | P a g e
a.Is depth buffering enabled?
If you're drawing a polygon that's behind another polygon, and depth test is enabled, then
the new polygon will typically lose the depth test, and no blending will occur. On the other hand,
if you've disabled depth test, the new polygon will be blended with the existing polygon,
regardless of whether it's behind or in front of it.
b.How can I make part of my texture maps transparent or translucent?
It depends on the effect you're trying to achieve.
If you want blending to occur after the texture has been applied, then use the OpenGL
blending feature. Try this:
glEnable (GL_BLEND); glBlendFunc (GL_ONE, GL_ONE);
You might want to use the alpha values that result from texture mapping in the blend
function. If so, (GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA) is always a good function
to start with.
However, if you want blending to occur when the primitive is texture mapped (i.e., you
want parts of the texture map to allow the underlying color of the primitive to show through),
then don't use OpenGL blending. Instead, you'd use glTexEnv(), and set the texture environment
mode to GL_BLEND. In this case, you'd want to leave the texture environment color to its
default value of (0,0,0)
1.1 – Train Rendering in OpenGl:
A virtual train along with view in 2D showing the intial rest position of the
.The entire scenery is constructed based on different OpenGl
16 | P a g e
functions along with other parameters.The construction basically consists of components
used such as ,we have constructed two metres..Clouds have also been constructed over the sky
for adding a good theme.Now the main purpose to serve is provided by the train which can be
driven over different directions along with various functions which I will be mentioning
later.Basically a set of functions along with main function served the purpose of developing
the abstract.
Uses: mouse interactions have been used to interact with the
Implementation.
A few to list out would be trustworthy for both users as well as me so that the points
May be crystal clear to the viewers.
2.SYSTEM ANALYSIS
2.1 Scope of the Project:
As per the concern being given to the scope we would definately say that this project will
give a rough idea to the students who are basically wondering of how the major games related
to train are being developed.The sourcecode used in this project is an outline view of the
scenery being constructed over which the games are implemented.The background plays a very
vital role along with the graphics used in the games.This project will just give a flashback
of background construction along with objects used in the games.Basically at the end I would
give a full stop to the scope by saying that the primary and main scope of the project is “A
doorstep for beginners of today to transform into Gamers of tomorrow”
17 | P a g e
2.2 Aim of the Project:
The primary aim of this project is to demonstrate the the motion of a train in different directions
as per the source code being used as well as presenting with mouse interaction to show various
textures and effects of the entire building over which the train is being driven.
3. REQUIREMENT SPECIFICATIO N
4.1 Software Requirements:
An MS-DOS based operating system like Windows 98, Windows 2000 or
Windows XP the platform required to develop the 2D and 2D graphics
applications.
A Visual C/C++ compiler is required for compiling the source code to make the
executable file which can then be directly executed.
A built in graphics library like glut and glut32, and header file like glut.h and also
dynamic link libraries like glut and glut32 are required for creating the 2D layout.
4.2 Hardware Requirements:
The hardware requirements are very minimal and the software can run on most of the machines.
Processor - Intel 486/Pentium processor or above.
18 | P a g e
Processor Speed - 500 MHz or above
RAM - 64MB or above Storage Space - 2 MB or above
Monitor resolution - A color monitor with a minimum resolution of 640*480
4.DESIGN PHASE
4.1 Introduction
This project is basically being constructed keeping in view the construction and simulationof a
train over a 2D animated building as told earlier.Basically the project undertaken by us has gone
through a variety of functions and headers along with a number of source codes.Now let me sort
out a few functions along with headers.Here I would basically brief out a few explanation of the
contents.
4.2 Modular Description
The major functions that are used in the creation of the program are as follows:
1. void init(void)
19 | P a g e
Let's start by looking at init(). It creates a display list for the torus and initializes the viewing
matrices and other rendering state.It also creates the starting window of the programme.
2: glutPostRedisplay()
Then glutPostRedisplay() is called, which will cause glutMainLoop() to call display() and
render the torus after other events have been processed. When the `i' key is
pressed, keyboard() restores the initial modelview matrix and returns the torus to its original
location.
3:display()
The display() function is very simple: It clears the window and then calls glCallList() to
execute the commands in the display list. If we hadn't used display lists, display() would have to
reissue the commands to draw the torus each time it was called.
A display list contains only OpenGL commands. In Example 1-7, only
the glBegin(), glVertex(), and glEnd() calls are stored in the display list. The parameters for the
calls are evaluated, and their values are copied into the display list when it is created. All the
trigonometry to create the torus is done only once, which should increase rendering performance.
However, the values in the display list can't be changed later. And once a command has been
stored in a list it is not possible to remove it. Neither can you add any new commands to the list
after it has been defined. You can delete the entire display list and create a new one, but you can't
edit it.
Note: Display lists also work well with GLU commands, since those operations are ultimately
broken down into low-level OpenGL commands, which can easily be stored in display lists. Use
of display lists with GLU is particularly important for optimizing performance of GLU
tessellators and NURBS.
We have different functions that makes use to create the fountain with simulated water, they
are as follows…
20 | P a g e
1:Cloud.cpp
This function is mainly used for the construction of the cloud which isfloating over the sky.The
function implementation may be stated as follows.
//dynamic object- Single cloud
#include <time.h>
// Material of cloud
materialStruct cloudShader = {{0.9f, 0.9f, 0.9f, 1.0f},
{0.9f, 0.9f, 0.9f, 0.7f},
{0.0f, 0.0f, 0.0f, 1.0f},
GLfloat x = 0.0;GLfloat y =0.0; GLfloat z = 0.0; GLfloat a = 0.0;
2:Ground.cpp
The function to add textured building to ground.
// Material of ground
materialStruct groundShader = {{0.0f, 0.0f, 0.0f, 1.0f},
{0.7f, 0.5f, 0.5f, 1.0f},
{0.7f, 0.7f, 0.7f, 1.0f},
{50.0f}};
21 | P a g e
3:Train.cpp
void TRAINS(int x1,int y1,int a,int b){ int i=0;
glBegin(GL_QUADS);glColor3f(0,0.0,1.0); //ENGINEglVertex2f(x1,y1); //lengh of engine=60;height of
engine=30;glColor3f(0,0.0,1.0);glVertex2f(x1+60,y1);glColor3f(1.0,0.0,0.0);glVertex2f(x1+60,y1-30);glColor3f(0,0.0,0.0);glVertex2f(x1,y1-30);glEnd();
while(i<3){ glBegin(GL_QUADS); //BOGIES
glColor3f(1.0,0.0,0.0); //For right train a=795,b=510glVertex2f(a,b);glColor3f(1.0,0.0,0.0);glVertex2f(a+60,b);glColor3f(1.0,0.0,0.0);glVertex2f(a+60,b-20);glColor3f(1.0,0.0,0.0);glVertex2f(a,b-20);glEnd();a+=65;i++;
}
}
4:Interface.cpp
An interface describes the behavior or capabilities of a C++ class without committing to a
particular implementation of that class.
The C++ interfaces are implemented using abstract classes and these abstract classes should not
be confused with data abstraction which is a concept of keeping implementation detail separate
from associated data.
A class is made abstract by declaring at least one of its functions as pure virtualfunction. A pure
virtual function is specified by placing "= 0" in its declaration as follows:
22 | P a g e
class Box
{
public:
// pure virtaul function
virtual double getVolume() = 0;
private:
double length; // Length of a box
double breadth; // Breadth of a box
double height; // Height of a box
};
The purpose of an abstract class (often referred to as an ABC) is to provide an appropriate base
class from which other classes can inherit. Abstract classes cannot be used to instantiate objects
and serves only as an interface. Attempting to instantiate an object of an abstract class causes a
compilation error.
Thus, if a subclass of an ABC needs to be instantiated, it has to implement each of the virtual
functions, which means that it supports the interface declared by the ABC. Failure to override a
pure virtual function in a derived class, then attempting to instantiate objects of that class, is a
compilation error.
Classes that can be used to instantiate objects are called concrete classes.
23 | P a g e
Abstract Class Example:
Consider the following example where parent class provides an interface to the base class to
implement a function called getArea():
#include <iostream>
using namespace std;
// Base class
class Shape
{
public:
// pure virtual function providing interface framework.
virtual int getArea() = 0;
void setWidth(int w)
{
width = w;
}
void setHeight(int h)
{
height = h;
}
protected:
int width;
24 | P a g e
5:Main.cpp
As all of us know the main contains all the functions stated earlier along with other parameters
useful to construct and implement the project.
4. CODE
#include<stdio.h>#include<stdlib.h>#include<GL/glut.h>#include <math.h>#include <time.h>#include <windows.h>#define M_PI 3.14
int c=0,d=500,g=380,h=970,i=540,j=970,k=380,l=965,m=540,n=970;GLfloat x=0.0,y=0.0;int z=0,a;int train1,basic;
//matrix
void sky(){
glBegin(GL_POLYGON);glColor3f(0,1,1);glVertex2f(0,730);glVertex2f(999,730);glVertex2f(999,999);glVertex2f(0,999);
25 | P a g e
glEnd();
}
void sleep(unsigned int mseconds){
clock_t goal = mseconds + clock(); while (goal > clock());}
void TRAINS(int x1,int y1,int a,int b){ int i=0;
glBegin(GL_QUADS);glColor3f(0,0.0,1.0); //ENGINEglVertex2f(x1,y1); //lengh of
engine=60;height of engine=30;glColor3f(0,0.0,1.0);glVertex2f(x1+60,y1);glColor3f(1.0,0.0,0.0);glVertex2f(x1+60,y1-30);glColor3f(0,0.0,0.0);glVertex2f(x1,y1-30);glEnd();
while(i<3){ glBegin(GL_QUADS); //BOGIES
glColor3f(1.0,0.0,0.0); //For right train a=795,b=510
glVertex2f(a,b);glColor3f(1.0,0.0,0.0);glVertex2f(a+60,b);glColor3f(1.0,0.0,0.0);glVertex2f(a+60,b-20);glColor3f(1.0,0.0,0.0);glVertex2f(a,b-20);glEnd();a+=65;i++;
}
}
26 | P a g e
void TRACKS(){
sky();/** Track **/glBegin(GL_LINES);
glColor3f(0.0,0.0,0.0);glVertex2f(0,500);glVertex2f(1000,500);glVertex2f(0,499);glVertex2f(1000,499);
glVertex2f(0,485);glVertex2f(1000,485);glVertex2f(0,486);glVertex2f(1000,486);while(c!=1000){
glVertex2f(c,d);glVertex2f(c,d-15);c+=10;
}glEnd();
}
void myinit(){ glClearColor(0.0,0.5,0.0,0.0); //background color
gluOrtho2D(0,999,0,999);glPointSize(2.0);glLineWidth(2.0);
basic = glGenLists(1);glNewList(basic, GL_COMPILE);TRACKS();
glEndList();
train1 = glGenLists(1);glNewList(train1, GL_COMPILE);TRAINS(730,520,795,510);
glEndList();}
27 | P a g e
void draw(void){
glClear(GL_COLOR_BUFFER_BIT);glPushMatrix();
glPushMatrix();glCallList(basic);
glPopMatrix();
glPushMatrix();glTranslatef(x,y,0.0);glCallList(train1);
glFlush();glPopMatrix();
if(z<198){ a+=5;
x=x-5.0;sleep(100);z++;
}
glPopMatrix();glutPostRedisplay();glFlush();
}void mouse(int button,int state,int x,int y){
switch(button){case GLUT_LEFT_BUTTON:
if(state==GLUT_DOWN)glutDisplayFunc(draw);
break;
case GLUT_RIGHT_BUTTON:if(state==GLUT_DOWN)
sleep(1000);break;
}}void main(){ glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowPosition(0,0);glutInitWindowSize(1200,700);
28 | P a g e
glutCreateWindow("Running Trains");glutMouseFunc(mouse);glutDisplayFunc(draw);myinit();
glutMainLoop ();}
Snapshot
29 | P a g e
30 | P a g e
7. CONCLUSION:-
The above project prepared on the topic “ Train ov “is successful and hopefully demonstrating
its working with the help of both mouse as well as keys interaction.The OpenGl source code
along with headers and othermain code helped us to prepare the project as per the
requirement.In future this conceptwill garnish and will act as a plus point in implementing a
game related to train.
31 | P a g e
8. Bibliography
Interactive Computer Graphics.
A Top-Down Approach using OpenGL- Edward Angel
http://en.wikipedia.org/wiki/OpenGL
http://www.google.co.in/
http://www.opengl.org/
32 | P a g e
top related