copter report (2)
TRANSCRIPT
-
8/3/2019 Copter Report (2)
1/44
ACKNOWLEDGEMENT
The satisfaction and euphoria that accompany the successful completion of any
task would be incomplete without the mention of the people who made it possible, whose
constant guidance and encouragement crowned my efforts with success. I would like to
express my deep sense of gratitude to our institution MSEC, for providing me the means
of attaining my most cherished goal.
We express our sincere thanks to our principal, Dr.RANAPRATAP REDDY for
his kind encouragement and support. I also extend my sincere thanks to Mr.VIJAYA
KUMAR H.O.D. of the department of CS&E, who encouraged me throughout this
case study.
We feel delighted to have this page to express our sincere thanks and deep
appreciation to our guide, Mr.ASHWIN KUMAR for valuable guidance, and keen
interest and constant encouragement through out the entire period of this project work.
We also convey my regards and deep sense of gratitude to all the lecturers of CS&E
department, my parents and my friends for their constant motivation.
Finally I consider my privilege to express my voice of gratitude and respect to all
those who guided and inspired me in the completion of this study.
Chapter 1: INTRODUCTION
-
8/3/2019 Copter Report (2)
2/44
About the Copter Game
Copter game is an OpenGL game for one player where you fly a helicopter
through a maze of obstacles. This version is the most popular of helicopter game, being
very easy to operate and required almost no skills at all.
Copter game graphics are very simple, one might say primitive. It's not a fancy
game, but rest assured that it is very enjoyable and people became addicted to this game
playing it over and over for hours.
Copter game is played using just two keys W and S on keyboard. You can only
navigate your copter up and down; it is a 3 dimensional game. By default the copter will
hit an obstacle n crash if you don't touch anything, so basically during the game you havethe press and release the button the way that fits the runway.
The goal of the game is to get the copter through the runway as far as you can go
without colliding with obstacles. You cannot touch the upper wall or the ground or you'll
be crashed, and there are also obstacles along the way that you must avoid.
Copter game is tough, there are no lifes, no second changes, the second your
helicopter touches anything it will crash and you will have to start the game all over, with
zero score.
Copter game, as simple as it may look, is really a challenge for all players of all
ages around the world. Even young players, which are playing sophisticated games with
amazing 3D graphics seems to enjoy playing the helicopter game.
Chapter 2: LITERATURE SUMMARY
2.1 What is OpenGL?
OpenGL provides a set of commands to render a three dimensional scene. That means
-
8/3/2019 Copter Report (2)
3/44
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 licencing.
OpenGL is a hardware- and system-independent interface. An OpenGL-application
will work on every platform, as long as there is an installed implementation.
Because it is system independent, there are no functions to create windows etc., but
there are helper functions for each platform. A very useful thing is GLUT.
2.2 What is GLUT?
GLUT is a complete API written by Mark Kilgard which lets you create windows and
handle the messages. It exists for several platforms, that means that a program which uses
GLUT can be compiled on many platforms without (or at least with very few) changes in
the code.
2.3 How does OpenGL work?
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 what ever with this color then. There are no classes like inDirectX. 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 glVertex3f(). 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.
A very important thing is to know, that there are two important matrices, which affect
the transformation from the 3d-world to the 2d-screen: The projection matrix and the
modelview matrix. The projection matrix contains information, how a vertex let's say a
-
8/3/2019 Copter Report (2)
4/44
"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.4 How can I use GLUT?
GLUT provides some routines for the initialization and creating the window (or
fullscreen mode, if you want to). Those functions are called first in a GLUT application:
In your first line you always write glutInit(&argc, argv). After this, you must tell
GLUT, which display mode you want. This is done by calling glutInitDisplayMode().
The symbolic constants are connected by a logical OR, so you could use
glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE). In later tutorials we will use some
more constants here.
After the initialization you call glCreateWindow() with the window name as
parameter.
Then you can (and should) pass some methods for certain events. The most important
ones are "reshape" and "display". Display should clear the so called color buffer let's
say this is the sheet of paper and draw our objects.
You pass the methods by glut*Func(), for example glutDisplayFunc(). At the end of the
main function you call glutMainLoop(). This function doesn't return, but calls the several
functions passed by glut*Func.
Chapter 3: SYSTEM REQUIREMENTS
3.1 HARDWARE REQUIREMENTS
Minimum hardware specification
Processor : Pentium processors
-
8/3/2019 Copter Report (2)
5/44
Main memory : 512 MB RAM
Hard Disk : 40 GB
3.2 SOFTWARE REQUIREMENTS
Minimum software specification
Operating system : Windows
Visual C++
OPENGL Library
Chapter4: FUNCTIONAL DESCRIPTION
Function Name Application
-
8/3/2019 Copter Report (2)
6/44
Void initLight();Hidden surface removal. Setup and enable
light0
int LoadBitmap()To load the bitmap texture.
void timer(); To calculate the score
void display3(); To display GAME OVER.
void display1(); To display all body parts of copter
void display2();To display success and failure status in
background.
Void keyboard();
Keyboard interface. To move the copter up
and down.
Void reset(); To reset the score to 0.
Void levelMenu(); Display the popup menu.
Chapter5: SYSTEM DESIGN
5.1 OPERATING SYSTEM:
An important program that runs on computer is the OS softwares. Every general-
purpose computer must have an operating system to run other programs. Operating
system performs basic tasks, such as recognizing output from the keyboard, sending
output to the display screen, keeping track of files and directories on the disk, and
-
8/3/2019 Copter Report (2)
7/44
controlling peripheral devices such as disk drivers and printers.
For large systems, the OS has an even greater responsibilities and powers. It is like a
traffic cop- it makes sure that different program and user running at same time do not
interfere with each other. The OS is also responsible for security, ensuring that
unauthorized users do not access the system.
5.2 CLASSIFICATION OF OPERATING SYSTEM:
Operating system can be classified as follows:
1. Multi-user:- Allows two or more users to run programs at the same time.
Some OS permit hundreds or even thousands of current users.
2. Multi processing: - Supports running a program on more than one CPU.
3. Multitasking: - Allows more than one program to run concurrently.
4. Multithreading: - Allows different parts of a single program to run
concurrently.
5. Real time: - Respond to inputs instantly. General-Purpose OS, such as
DOS and UNIX are not real time.
Operating system provides a software platform on the top of which other program can
run. The application program must be written to run on the top of a particular OS your
choice of OS, therefore, determines to a great extend the application you can run. For PCs
the most popular OS are DOS, OS/2 and windows, but others are available, such as
LINUX. Os can be explored from two points of view; user and the system.
5.3 USER VIEW:
Some users sit at a terminal connected to a mainframe or a minicomputer. Other users
are accessing the same computer though other terminals. These users share resources and
may exchange information the OS is designed to maximize resources utilization to assure
that all available CPU time, memory and I/O are used efficiently and that no individual
user takes more than their fare share. Other users sit work station connected to networks
-
8/3/2019 Copter Report (2)
8/44
of other workstations and servers. These users dedicated resources of their disposal, but
they also share resources such as networking and servers file, compute and Print
servers. Therefore, their OS is designed to compromise between individual usability and
resources utilization.
Some computers have a little or no user views. For example, embedded computers in
home devices and automobiles may have numeric key pad and many turn indicator lights
on or off to show status, but mostly they are their OS and designed to run without user
intervention. As user normally interact with the OS through a set of commands. For
example, the commands such as COPY and RENAME for copying and changing the
names of files, respectively. The commands are accepted and executed by a part of the
OS called the command processor command line interpreter. Graphical user interfaces
allow you to enter commands by pointing and clicking at objects that appear on the
screen.
5.4SYSTEM VIEW:
From the computers point of view, the OS is the program that is most intimate with
the hardware. We can view the OS as a resource allocator. A computer system has many
resources-hardware and software that may be required to solve a problem CPU time,
memory space, file storage space, I/O devices are and so on. The OS acts as a manager of
these resources. Facing numerous and possibly conflicting resources, the OS must decide
how to specify programs and users so that it can operate the computer system efficiently
and fairly.
An OS is a control program. A control program manages the execution of user
programs to prevent errors and improper use of the computer. It especially concerns with
the operation and control of input and output devices. In general, however we have no
complete adequate definition of an OS. OS exist because it is a responsible way to solve
the problem of creating a usable computer system.
The fundamental goal of computer systems is to execute user programs and make
solving user problems easier. Towards this goal, computer hardware is constructed. Since
bare hardware alone is not particularly easy to use, application programs are developed.
-
8/3/2019 Copter Report (2)
9/44
These programs require certain common operations such as those controlling and
allocating resources is then brought together into piece of software.
5.5 DESIGN:
We have no universally accepted definition of which is part of the OS. A simple
viewpoint is that it includes everything a vendor ships when you order The Operating
System. The storage (memory, disks and tapes) requirements and features included,
however, vary greatly across systems. A more common definition is that OS the one
program running at all times on the computer (usually called Kernel), with all else being
application programs.
The matter of what constitutes an OS is becoming important. In 1998 the United
States department of Justice filed suit against Microsoft in essence claiming that
Microsoft included too much functionality in its OS and thus prevented competition and
application vendors. The primary goal of OS is convenience the users. This view is
particularly clear when you look at OS for small PCs. The primary goal of other OS is
efficient operation of computer system. This is the case for the large, shared, multi-user
system. These systems are expensive, so it is desirable to make them. This view is
particularly clear when you look at OS for small PCs.
Chapter6: DATAFLOW DIAGRAM
-
8/3/2019 Copter Report (2)
10/44
Chapter7: IMPLEMENTATION
7.1 HEADER FILES
#include
#include
#include
#include
#include
#include
-
8/3/2019 Copter Report (2)
11/44
#include
#include
7.2 FUNCTIONS
7.2.1 glLightfv Function
The glLightfv function returns light source parameter values.
SYNTAX:
void glLightfv(GLenum light, GLenum pname, GLfloat *params);
PARAMETERS:
1. light: They are identified by symbolic names of the form GL_LIGHTi where i is a
value: 0 to GL_MAX_LIGHTS - 1.
2. pname: A light source parameter for light. The following symbolic names are
accepted: 1.GL_DIFFUSE 2.GL_SPECULAR
7.2.2 glPushMatrix, glPopMatrix Function
The glPushMatrix and glPopMatrix functions push and pop the current matrix
stack.
SYNTAX:
void glPushMatrix, glPopMatrix(void);
PARAMETERS: This function has no parameters.3. glPushMatrix();
4. glPopMatrix();
7.2.3 glEnable, glDisable Function
The glEnable and glDisable functions enable or disable OpenGL capabilities.
SYNTAX:
void glEnable, glDisable(GLenum cap);
PARAMETERS:
5. cap: A symbolic constant indicating an OpenGL capability.
6. glEnable(GL_CULL_FACE);
7. glDisable(GL_CULL_FACE);
7.2.4 glColor3f Function
Sets the current color.
-
8/3/2019 Copter Report (2)
12/44
SYNTAX:
void glColor3f(GLfloat red, GLfloat green, GLfloat blue);
7.2.5 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:
8. mode: its possible values are: 1.GL_LINES 2. GL_LINE_STRIP
3.GL_LINE_LOOP 4. GL_TRIANGLES 5. GL_QUADS
7.2.6 glNormal3f Function
Sets the current normal vector.
SYNTAX:
void glNormal3b(GLfloat12 nx, GLfloat ny, GLfloat nz);
9. glNormal3f(1.0,0.0,0.0);
7.2.7 glVertex3f Function
Specifies a vertex.
SYNTAX:
void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
10. glVertex3f(-3.0,3.0,4.0);
7.2.8 glRotatef Function
The glRotated and glRotatef functions multiply the current matrix by a rotation
matrix.
SYNTAX:
void glRotate( GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
11. glRotatef(xrot,1.0,0.0,0.0);
7.2.9 glTranslate Function
The glTranslated and glTranslatef functions multiply the current matrix by a
translation matrix.
SYNTAX:
void glTranslate( x, y, z);
-
8/3/2019 Copter Report (2)
13/44
12. glTranslatef(0.0,0.0,-1.0);
7.2.10 glScalef Function
The glScaled and glScalef functions multiply the current matrix by a general
scaling matrix.
SYNTAX:
void glScalef(GLfloat x, GLfloat y, GLfloat z);
glScalef(1.0,1.0,-1.0);
7.3 FUNCTIONS USED TO DISPLAY
7.3.1 glClear Function
The glClear function clears buffers to preset values.
SYNTAX:
glClear(GLbitfield mask);
PARAMETERS:
13. mask: the possible used for this are: 1. GL_COLOR_BUFFER_BIT
14. GL_DEPTH_BUFFER_BIT glClear(GL_COLOR_BUFFER_BIT|
GL_DEPTH_BUFFER_BIT);
7.3.2. glMatrixMode Function
The glMatrixMode function specifies which matrix is the current matrix.
SYNTAX:
void glMatrixMode(GLenum mode);
PARAMETERS:
15. Mode: it can take GL_MODELVIEW as its value.
glMatrixMode(GL_MODELVIEW);
7.3.3 glLoadIdentity Function
The glLoadIdentity function replaces the current matrix with the identity matrix.
SYNTAX:
void glLoadIdentity(void);
PARAMETERS:
This function has no parameters.
glLoadIdentity();
-
8/3/2019 Copter Report (2)
14/44
7.3.4 glPushAttrib, glPopAttrib
Pushes or pops the attribute stack.
glPushAttrib Pushes the attribute stack.
glPopAttrib Pops the attribute stack.
glPushAttrib(0xffffffff);
glPopAttrib();
7.3.5 glColor4f Function
Sets the current color.
SYNTAX:
void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
16. glColor4f(0.0,0.0,0.0,0.05);
7.3.6 glutSwapBuffers
glutSwapBuffers swaps the buffers of the current window if double buffered.
SYNTAX:
void glutSwapBuffers(void);
17. glutSwapBuffers();
7.4 FUNCTIONS USED TO RESHAPE
7.4.1 glViewport Function
The glViewport function sets the viewport.
SYNTAX:
void glViewport(x, y,width, height);
18. glViewport(0,0,w,h);
7.4.2 gluPerspective Function
set up a perspective projection matrix
SYNTAX:
void gluPerspective( GLdouble fovy, GLdouble aspect, GLdouble zNear,
GLdouble zFar );
PARAMETERS:
19. fovy: Specifies the field of view angle, in degrees, in the y-direction.
20. aspect: Specifies the aspect ratio that determines the field of view in the x direction.
-
8/3/2019 Copter Report (2)
15/44
The aspect ratio is the ratio of x (width) to y (height).
21. zNear: Specifies the distance from the viewer to the near clipping plane (always
positive).
22. zFar: Specifies the distance from the viewer to the far clipping plane (always
positive).
23. gluPerspective(50.0,(float)w/(float)h,1.0,20.0);
7.4.3 glutTimerFunc
PARAMETERS:
24. msecs: Number of milliseconds to pass before calling the callback.
25. func: The timer callback function.
26. value: Integer value to pass to the timer callback.
27. glutTimerFunc(TIMER,timer,0);
7.4.4 glMaterialfv Function
The glMaterialfv function specifies material parameters for the lighting model.
SYNTAX:
void glMaterialfv(GLenum face, GLenum pname, const GLfloat params);
PARAMETERS:
28. face: GL_FRONT, GL_BACK, or GL_FRONT and GL_BACK.
29. pname: 1.GL_DIFFUSE 2.GL_SPECULAR
30. glMaterialfv(GL_FRONT,GL_SPECULAR,white);
7.4.2 glColorMaterial Function
The glColorMaterial function causes a material color to track the current color.
SYNTAX:
void glColorMaterial(GLenum face, GLenum mode);
PARAMETERS:
31. face: Accepted values are GL_FRONT, GL_BACK, and GL_FRONT_AND_BACK.
The default value is GL_FRONT_AND_BACK.
32. mode: Accepted values are GL_EMISSION, GL_AMBIENT, GL_DIFFUSE,
GL_SPECULAR, and GL_AMBIENT_AND_DIFFUSE. The default value is
GL_AMBIENT_AND_DIFFUSE.
33. glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE);
-
8/3/2019 Copter Report (2)
16/44
7.4.3 glutDisplayFunc Function
glutDisplayFunc sets the display callback for the current window.
SYNTAX:
void glutDisplayFunc(void (*func)(void));
PARAMETERS:
34. func; The new display callback function.
35. glutDisplayFunc(display);
7.4.4 glutReshapeFunc Function
glutReshapeFunc sets the reshape callback for the current window.
SYNTAX:
void glutReshapeFunc(void (*func)(int width, int height));
PARAMETERS:
36. func; The new reshape callback function.
37. glutReshapeFunc(reshape);
7.5 MAIN FUNCTION
7.5.1. glutInit Function
glutInit is used to initialize the GLUT library.
SYNTAX:glutInit(int *argcp, char **argv);
PARAMETERS:
38. argcp; A pointer to the program's unmodified argc variable from main. Upon return,
the value pointed to by argcp will be updated.
39. argv: The program's unmodified argv variable from main. Like argcp, the data for
argv will be updated.
40. glutInit(&argc,argv);
7.5.2. glutInitDisplayMode Function
glutInitDisplayMode sets the initial display mode.
SYNTAX:
void glutInitDisplayMode(unsigned int mode);
PARAMETERS:
-
8/3/2019 Copter Report (2)
17/44
41. mode: 1. GLUT_RGB 2.GLUT_DOUBLE 3.GLUT_SINGLE
4.GLUT_DEPTH
42. glutInitDisplayMode(GLUT_RGB|GLUT_DEPTH|GLUT_DOUBLE);
7.5.3. glutInitWindowPosition, glutInitWindowSize Functions
glutInitWindowPosition and glutInitWindowSize set the initial window position
and size respectively.
SYNTAX:
void glutInitWindowSize(int width, int height);
void glutInitWindowPosition(int x, int y);
43. glutInitWindowSize(300,300);
7.5.4. glutCreateWindow Function
glutCreateWindow creates a top-level window.
SYNTAX:
int glutCreateWindow(char *name);
44. glutCreateWindow("two pass mirror");
7.5.5. glutMainLoop Function
glutMainLoop enters the GLUT event processing loop.
SYNTAX:
void glutMainLoop(void);
45. glutMainLoop();
Chapter8: TESTING
Software testing can be stated as the process of validating and verifying that a software
program/application :
1. meets the requirements that guided its design and development;
2. works as expected; and
3. can be implemented with the same characteristics anywhere
Here most of the test effort has occurred after the requirements have been defined and the
coding process has been completed.
We carried out this test for the following reasons:
-
8/3/2019 Copter Report (2)
18/44
46. Examination of code as well as execution of that code in various environments
and conditions as well as examining the aspects of code: does it do what it is
supposed to do and do what it needs to do.
47. Functional testing was carried out in order to find "can the user do this" or "does
this particular feature work".
Chapter9: SCREEN SHOTS
Level- submenu, to choose the level
Game in progress
-
8/3/2019 Copter Report (2)
19/44
Display of GAME OVER when obstacle hits the copter
Chapter 10: CONCLUSION
We started with modest aim with no prior experience in any programming projects as
this, but ended up in learning many things, fine tuning the programmingskills and
getting into the real world of software development with an exposure to corporate
environment. During the development of any software of significant utility, we are faced
with the trade-off between speed of execution and amount of memory consumed. This is
simple interactive application . It is extremely user friendly and has the features, which
makes simple graphics project. It has an open source code and no security features has
been included. The user is free to alter the code for feature enhancement. Checking and
verification of all possible types of the functions are taken care. Care was taken to avoid
bugs. Bugs may be reported to creator as the need may be .So, we conclude on note that
we are looking forward to develop more such projects with an appetite to learn more in
computer graphics.
-
8/3/2019 Copter Report (2)
20/44
-
8/3/2019 Copter Report (2)
21/44
Chapter12: REFERENCES
48. Interactive Computer Graphics: A Top Down Approach with
OpenGL- Edward Angel, 5th Edition, Addison-Wellesley,2008
2. OpenGL SuperBible: Comprehensive Tutorial and Reference-
Richard S.Wright, Jr. and others, 4th Edition, Addison
-
8/3/2019 Copter Report (2)
22/44
Chapter 13: SOURCE CODE
#pragma once
#ifndef _WIN32_WINNT
#define _WIN32_WINNT 0x0600
#endif
extern int num_texture;
extern int LoadBitmap(char *filename);
#include
#include
#include
#include
#include
#include
#include
#include
#include
int num_texture=0;
char *s;
void *font = GLUT_BITMAP_TIMES_ROMAN_24;
void *font1=GLUT_BITMAP_8_BY_13 ;
int id_rock,id_dummy,id_top,id_btm;int score=0,level=1,start=0,flag=1;
GLfloat globalAmbient[] = { 0.1,0.1,0.1 };
GLfloat ambientLight[]={0.4,0.4,0.4};
GLfloat diffuseLight[] = { 0.8,0.8,0.8 };
GLfloat specularLight[]={0.5,0.5,0.5};
-
8/3/2019 Copter Report (2)
23/44
GLfloat lightPos[] = { 0,25,0 };
float mcolor[] = { 1, 0, 1, 1};
void initLight()
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT,globalAmbient);
glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight);
glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight);
glLightfv(GL_LIGHT0,GL_DIFFUSE,specularLight);
glLightfv(GL_LIGHT0,GL_POSITION,lightPos);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mcolor);
glMateriali(GL_FRONT, GL_SHININESS, 100);
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
}
float a[4][3]={7.0,-1.5,0,
7.2,-1.5,0,
7.2,-2.5,0,
7,-2.5,0};
float a1[4][3]={14.0,-1.5,0,
14.2,-1.5,0,
14.2,-2.5,0,
14,-2.5,0};
float a2[4][3]={10.0,-1.5,0,
10.2,-1.5,0,
10.2,-2.5,0,
10,-2.5,0};
-
8/3/2019 Copter Report (2)
24/44
float b[4][3]={-6,3.88,0,6,3.88,0,6,5,0,-6,5,0};
float c[4][3]={-6,-5,0,6,-5,0,6,-3.88,0,-6,-3.88,0};
float d[4][3]={2.5,-4.2,1,4,-4.2,1,4,-3.6,1,2.5,-3.6,1};
float e[4][3]={-2,0,0,4,0,0,2,3,0,-2,3,0};
float left_mov=0;
float left_mov1=0;
float left_mov2=0;
int rand_y=2;
int rand_y1=3;
int rand_y2=0;
void drawcube();
int LoadBitmap(char *filename)
{
int i, j=0; //Index variables
FILE *l_file; //File pointer
unsigned char *l_texture;
BITMAPFILEHEADER fileheader;
BITMAPINFOHEADER infoheader;
RGBTRIPLE rgb;
num_texture++;
if( (l_file = fopen(filename, "rb"))==NULL) return (-1);
fread(&fileheader, sizeof(fileheader), 1, l_file);
fseek(l_file, sizeof(fileheader), SEEK_SET);
fread(&infoheader, sizeof(infoheader), 1, l_file);
l_texture = (byte *) malloc(infoheader.biWidth * infoheader.biHeight * 4);
memset(l_texture, 0, infoheader.biWidth * infoheader.biHeight * 4);
for (i=0; i < infoheader.biWidth*infoheader.biHeight; i++)
{
fread(&rgb, sizeof(rgb), 1, l_file);
l_texture[j+0] = rgb.rgbtRed;
l_texture[j+1] = rgb.rgbtGreen;
-
8/3/2019 Copter Report (2)
25/44
l_texture[j+2] = rgb.rgbtBlue;
l_texture[j+3] = 255;
j += 4;
}
fclose(l_file);
glBindTexture(GL_TEXTURE_2D, num_texture);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_NEAREST);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexImage2D(GL_TEXTURE_2D, 0, 4, infoheader.biWidth, infoheader.biHeight, 0,
GL_RGBA, GL_UNSIGNED_BYTE, l_texture);
gluBuild2DMipmaps(GL_TEXTURE_2D, 4, infoheader.biWidth,
infoheader.biHeight, GL_RGBA, GL_UNSIGNED_BYTE, l_texture);
free(l_texture);
return (num_texture);
}
GLUquadricObj *body,*back,*sidepipe;
float wx=-4,wy=0,wz=-6;
float gx=wx+2,gy=wy,gz=wz;
int fanangle=0;
int i=0;
float backpoint=0;
int angle=180;
void init()
{
glClearColor(0,0,0,0);
glEnable(GL_DEPTH_TEST);
-
8/3/2019 Copter Report (2)
26/44
glEnable(GL_TEXTURE_2D);
body=gluNewQuadric();
back=gluNewQuadric();
sidepipe=gluNewQuadric();
glEnable(GL_TEXTURE_2D);
id_rock=LoadBitmap("wood.bmp");
id_dummy=LoadBitmap("dummy.bmp");
id_top=id_btm=LoadBitmap("bot.bmp");
initLight();
}
void display2();
void output(float x, float y, float z,void *font, char *string)
{
int len=0, i;
glRasterPos3f(x, y, z);
printf("%d",len);
len = (int) strlen(string);
for (i = 0; i < len; i++)
{
glutBitmapCharacter(font, string[i]);
}
}
void drawPoly1(float a[4][3])
{ glPushMatrix();
glColor3f(1.0,1.0,1.0);
glBegin(GL_QUADS);
glVertex3fv(a[0]);
glVertex3fv(a[1]);
glVertex3fv(a[2]);
glVertex3fv(a[3]);
glEnd();
-
8/3/2019 Copter Report (2)
27/44
glFlush();
glPopMatrix();
}
void drawPoly(float a[4][3])
{
glBegin(GL_QUADS);
glTexCoord2f(0,0);
glVertex3fv(a[0]);
glTexCoord2f(0,1);
glVertex3fv(a[1]);
glTexCoord2f(1,1);
glVertex3fv(a[2]);
glTexCoord2f(1,0);
glVertex3fv(a[3]);
glEnd();
glFlush();
}
void timer(int val)
{
score=score+level;
glutTimerFunc(200,timer,1);
}
void display3()
{
printf("asjdkajdsa");
output(2,1,-2,font,"GAME OVER kahkjahdkj hkashdkajshdkjad asdasd");
}
void display1()
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
-
8/3/2019 Copter Report (2)
28/44
glLoadIdentity();
gluLookAt(0,5,10,0,0,-2,0,1,0);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glColor3f(0.7,0,1.0);
output(-1.2,4,4,font,"COPTER GAME");
output(-6,-7,-10,font1,"Right Click to Enter into the Game");
if(start==1)
display2();
else
{
glBindTexture(GL_TEXTURE_2D, id_dummy);
glPushMatrix();
wx=-1;
wy=-2;
glTranslatef(wx,wy,wz);
glRotatef(angle,0,1,0);
glTranslatef(-wx,-wy,-wz);
glPushMatrix();
glScalef(.5,.5,.5);
glColor3f(0.3,0.3,0.5);
glPushMatrix();
glTranslatef(wx-3,wy,wz);
glScalef(1,1,.7);
gluSphere(body,1.5,30,30);
glScalef(1,1,1.3);
glTranslatef(wx+0.6-wx,wy-wy,wz-wz);
glScalef(1,1,.7);
gluSphere(body,1.5,30,30);
glPopMatrix();
glColor3f(0,0,1);
-
8/3/2019 Copter Report (2)
29/44
glPushMatrix();
glTranslatef(wx-2.5,wy+1.5,wz);
glRotatef(180,0,1,0);
glScalef(.5,5,.5);
glutSolidCube(0.3);
glPopMatrix();
glColor3f(1,0,1);
glPushMatrix();
glTranslatef(wx-2.5,wy+2.1,wz);
glRotatef(fanangle,0,1,0);
glScalef(14,.5,.5);
glutSolidCube(.3);
glPopMatrix();
glPushMatrix();
glTranslatef(wx-2.5,wy+2.1,wz);
glRotatef(fanangle,0,1,0);
glScalef(.5,.5,14);
glutSolidCube(.3);
glPopMatrix();
glPushMatrix();
glColor3f(0.1,0.1,0.2);
glTranslatef(wx-2,wy+0.4,wz);
glScalef(1,0.6,.8);
glRotatef(90,0,1,0);
gluCylinder(back,1.2,0.5,4,30,30);
glPopMatrix();
glPushMatrix();
glColor3f(0.2,0.2,0.2);
glTranslatef(wx-2,wy+0.4,wz);
glRotatef(90,0,1,0);
gluCylinder(back,1.0,0.5,4,30,30);
-
8/3/2019 Copter Report (2)
30/44
glPopMatrix();
glPushMatrix();
glTranslatef(wx+2,wy+0.4,wz);
glRotatef(90,0,1,0);
gluCylinder(back,0.5,0.3,1,30,30);
glPopMatrix();
glPushMatrix();
glColor3f(0,0,1);
glTranslatef(wx+3,wy+0.4,wz);
gluSphere(back,0.3,30,30);
glPopMatrix();
glColor3f(1,0,1);
glPushMatrix();
glTranslatef(wx+3,wy+0.3,wz);
glRotatef(fanangle,1,0,0);
glScalef(0.5,13,.5);
glutSolidCube(.3);
glPopMatrix();
glPushMatrix();
glTranslatef(wx+3,wy+0.3,wz);
glRotatef(fanangle,1,0,0);
glScalef(0.5,0.5,14);
glutSolidCube(.3);
glPopMatrix();
glPushMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
fanangle=(fanangle+5)%360;
glutSwapBuffers();
glutPostRedisplay();
-
8/3/2019 Copter Report (2)
31/44
}
}
void display2()
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
gluLookAt(0,0,10,0,0,-1,0,1,0);
wx=-4;
output(1.01,-4.05,1 ,font,"SCORE");
char * b1= new char [50];
itoa(score, b1, 10); //b
if(score
-
8/3/2019 Copter Report (2)
32/44
a1[2][0]=14.2-left_mov1;
a1[3][0]=14-left_mov1;
a1[0][1]=-1.5+rand_y1;
a1[1][1]=-1.5+rand_y1;
a1[2][1]=-2.5+rand_y1;
a1[3][1]=-2.5+rand_y1;
drawPoly(a2);
a2[0][0]=10-left_mov2;
a2[1][0]=10.2-left_mov2;
a2[2][0]=10.2-left_mov2;
a2[3][0]=10-left_mov2;
a2[0][1]=-1.5+rand_y2;
a2[1][1]=-1.5+rand_y2;
a2[2][1]=-2.5+rand_y2;
a2[3][1]=-2.5+rand_y2;
glFlush();
}
drawPoly1(d);
glFlush();
float cent=(a[0][1]+a[2][1])/2;
float cent1=(a1[0][1]+a1[2][1])/2;
float cent2=(a2[0][1]+a2[2][1])/2;
printf("gy=%f\n",gy/2);
printf("cent=%f\n",cent);
printf("a[0][0]=%f\n",a[0][0]);
printf("gx=%f\n\n",gx);
printf("gy=%f\n",gy/2);
printf("cent1=%f\n",cent1);
printf("a1[0][0]=%f\n",a1[0][0]);
printf("gx=%f\n\n",gx);
if(gy/2==cent && (int)a[0][0]=(int)wx)
-
8/3/2019 Copter Report (2)
33/44
{
printf("Success00000000000000000");
flag=0;
}
if(gy/2==cent1 && (int)a1[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;;
}
if(gy/2==cent2 && (int)a2[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)-0.25==cent && (int)a[0][0]=(int)wx)
{
printf("Success00000000000000000");
flag=0;
}
if((gy/2)-0.25==cent1 && (int)a1[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)-0.25==cent2 && (int)a2[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)+0.25==cent && (int)a[0][0]=(int)wx)
{
-
8/3/2019 Copter Report (2)
34/44
printf("Success00000000000000000");
flag=0;
}
if((gy/2)+0.25==cent1 && (int)a1[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)+0.25==cent2 && (int)a2[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)-0.50==cent && (int)a[0][0]=(int)wx)
{
printf("Success00000000000000000");
flag=0;
}
if((gy/2)-0.50==cent1 && (int)a1[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)-0.50==cent2 && (int)a2[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)+0.50==cent && (int)a[0][0]=(int)wx)
{
-
8/3/2019 Copter Report (2)
35/44
printf("Success00000000000000000");
flag=0;
}
if((gy/2)+0.50==cent1 && (int)a1[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)+0.50==cent2 && (int)a2[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)+0.75==cent && (int)a[0][0]=(int)wx)
{
printf("Success00000000000000000");
flag=0;
}
if((gy/2)+0.75==cent1 && (int)a1[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)+0.75==cent2 && (int)a2[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)-0.75==cent && (int)a[0][0]=(int)wx)
{
printf("Success00000000000000000");
-
8/3/2019 Copter Report (2)
36/44
flag=0;
}
if((gy/2)-0.75==cent1 && (int)a1[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)-0.75==cent2 && (int)a2[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)+1==cent && (int)a[0][0]=(int)wx)
{
printf("Success00000000000000000");
flag=0;
}
if((gy/2)+1==cent1 && (int)a1[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)+1==cent2 && (int)a2[0][0]=(int)wx)
{
printf("Success1111111111111111");
flag=0;
}
if((gy/2)+1==4)
{
flag=0;
}
-
8/3/2019 Copter Report (2)
37/44
if((gy/2)-.75==-4)
{
flag=0;
}
glPushMatrix();
glBindTexture(GL_TEXTURE_2D, id_top);
drawPoly(b);
glBindTexture(GL_TEXTURE_2D, id_btm);
drawPoly(c);
glPopMatrix();
glPopMatrix();
if (level==1)
{
left_mov+=0.04;
left_mov1+=0.04;
left_mov2+=0.03;
}
if (level==2)
{
left_mov+=0.07;
left_mov1+=0.03;
left_mov2+=0.04;
}
if(flag==1)
{
if(left_mov>16)
{
left_mov=0;
rand_y=(rand()*rand())%6;
a[0][0]=7;
a[1][0]=7.2;
-
8/3/2019 Copter Report (2)
38/44
a[2][0]=7.2;
a[3][0]=7;
a[0][1]=-1.5;
a[1][1]=-1.5;
a[2][1]=-2.5;
a[3][1]=-2.5;
}
if(left_mov1>20)
{
left_mov1=0;
rand_y1=(rand()*rand())%6;
a1[0][0]=14;
a1[1][0]=14.2;
a1[2][0]=14.2;
a1[3][0]=14;
a1[0][1]=-1.5;
a1[1][1]=-1.5;
a1[2][1]=-2.5;
a1[3][1]=-2.5;
}
if(left_mov2>18)
{
left_mov2=0;
rand_y2=(rand()*rand())%6;
a2[0][0]=10;
a2[1][0]=10.2;
a2[2][0]=10.2;
a2[3][0]=10;
a2[0][1]=-1.5;
a2[1][1]=-1.5;
a2[2][1]=-2.5;
-
8/3/2019 Copter Report (2)
39/44
a2[3][1]=-2.5;
}
}
glBindTexture(GL_TEXTURE_2D, id_dummy);
glPushMatrix();
glTranslatef(wx,wy,wz);
glRotatef(angle,0,1,0);
glTranslatef(-wx,-wy,-wz);
glPushMatrix();
glScalef(.5,.5,.5);
glColor3f(0.3,0.3,0.5);
glPushMatrix();
glTranslatef(wx-3,wy,wz);
glScalef(1,1,.7);
gluSphere(body,1.5,30,30);
glScalef(1,1,1.3);
glTranslatef(wx+0.6-wx,wy-wy,wz-wz);
glScalef(1,1,.7);
gluSphere(body,1.5,30,30);
glPopMatrix();
glColor3f(0,0,1);
glPushMatrix();
glTranslatef(wx-2.5,wy+1.5,wz);
glRotatef(180,0,1,0);
glScalef(.5,5,.5);
glutSolidCube(0.3);
glPopMatrix();
glColor3f(1,0,1);
glPushMatrix();
glTranslatef(wx-2.5,wy+2.1,wz);
glRotatef(fanangle,0,1,0);
-
8/3/2019 Copter Report (2)
40/44
glScalef(14,.5,.5);
glutSolidCube(.3);
glPopMatrix();
glPushMatrix();
glTranslatef(wx-2.5,wy+2.1,wz);
glRotatef(fanangle,0,1,0);
glScalef(.5,.5,14);
glutSolidCube(.3);
glPopMatrix();
glPushMatrix();
glColor3f(0.1,0.1,0.2);
glTranslatef(wx-2,wy+0.4,wz);
glScalef(1,0.6,.8);
glRotatef(90,0,1,0);
gluCylinder(back,1.2,0.5,4,30,30);
glPopMatrix();
glPushMatrix();
glColor3f(0.2,0.2,0.2);
glTranslatef(wx-2,wy+0.4,wz);
glRotatef(90,0,1,0);
gluCylinder(back,1.0,0.5,4,30,30);
glPopMatrix();
glPushMatrix();
glTranslatef(wx+2,wy+0.4,wz);
glRotatef(90,0,1,0);
gluCylinder(back,0.5,0.3,1,30,30);
glPopMatrix();
glPushMatrix();
glColor3f(0,0,1);
glTranslatef(wx+3,wy+0.4,wz);
gluSphere(back,0.3,30,30);
-
8/3/2019 Copter Report (2)
41/44
glPopMatrix();
glColor3f(1,0,1);
glPushMatrix();
glTranslatef(wx+3,wy+0.3,wz);
glRotatef(fanangle,1,0,0);
glScalef(0.5,13,.5);
glutSolidCube(.3);
glPopMatrix();
glPushMatrix();
glTranslatef(wx+3,wy+0.3,wz);
glRotatef(fanangle,1,0,0);
glScalef(0.5,0.5,14);
glutSolidCube(.3);
glPopMatrix();
glPushMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
if(flag==0)
output(-1.8,2,3,font,"GAME OVER");
fanangle=(fanangle+5)%360;
glutSwapBuffers();
if(flag==1)
{
glutPostRedisplay();
}
}
void reshape(int w,int h)
{
if(h==0)
h=1;
-
8/3/2019 Copter Report (2)
42/44
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(52.0f,w/h,1,1000);
glMatrixMode(GL_MODELVIEW);
}
void keyboard(unsigned char key,int x,int y)
{
switch(key)
{
case 27:
exit(0);
break;
case 'w':
if(wy-13)
wy--;
gy=wy/2;
break;
}
}
void reset()
{
score=0;
}
void Copter(int id)
{
-
8/3/2019 Copter Report (2)
43/44
switch(id)
{
case 1:exit(0);
break;
case 2:start=1;
break;
default :break;
}
glutPostRedisplay();
}
void levelMenu(int id)
{
switch(id)
{
case 4:level=1;
reset();
break;
case 5:level=2;
reset();
break;
default :break;
}
glutPostRedisplay();
}
int main()
{
glutInitDisplayMode(GLUT_DOUBLE|GLUT_DEPTH|GLUT_RGB);
glutInitWindowSize(700,600);
glutInitWindowPosition(0,0);
glutCreateWindow("copter game");
init();
-
8/3/2019 Copter Report (2)
44/44
glutDisplayFunc(display1);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutTimerFunc(200,timer,1);
int sub_menu=glutCreateMenu(levelMenu);
glutAddMenuEntry("Level 1",4);
glutAddMenuEntry("Level 2",5);
glutCreateMenu(Copter);
glutAddMenuEntry("Start Game",2);
glutAddSubMenu("Level",sub_menu);
glutAddMenuEntry("Quit",1);
glutAttachMenu(GLUT_RIGHT_BUTTON);
glutMainLoop();
return 0;
}