You are on page 1of 38

VISVESVARAYA TECHNOLOGICAL UNIVERSITY

BELGAUM

A PROJECT REPORT On MULTI-WINDOW LIGHT EFFECTS


Submitted in partial fulfilment of the Bachelor Degree In

Computer Science and Engineering


VI SEM COMPUTER GRAPHICS AND VISUALIZATION LABORATORY PROJECT (06CSL67) For the academic Year: 2011-2012 By

Mr. SAIPREETH MURALIDHARAN (1HK09CS046) & Mr. MUZAMMIL BASHA S.J. (IHK09CS033)
Under the guidance of

Mrs. SHAHZIA SIDDIQUA


Lecturer, CSE HKBKCE, Bangalore

HKBK COLLEGE

of ENGINEERING

Nagawara, Bangalore 560 045 Email: info@hkbkeducation.org URL: www.hkbkeducation.org


Department of CSE, HKBKCE

2011-2012

HKBK COLLEGEofENGINEERING
Nagawara, Bengaluru560 045
Approved by AICTE & Affiliated to VTU

Department of Computer Science and Engineering


Certificate
Certified that the project work entitled Multi-Window Light Effects is carried out by Mr. Saipreeth Muralidharan-

1HK09CS046 and Mr.Muzammil Basha.S.J.-1HK09CS033, are bonafide students of


HKBK COLLEGEofENGINEERING,

in partial fulfillment for

the award of Bachelor of Engineering in Computer Science and Engineering of the Visveshwaraya Technological University, Belgaum, during the year 201112. It is certified that all

corrections/suggestions indicated for Internal Assessment have been incorporated in the report deposited in the departmental library. The project report has been approved as it satisfies the academic requirements in respect of 06CSL67Computer Graphics and Visualization Lab prescribed for the said Degree.
__________________________________ Ms. Shahzia Siddiqua Guide _____________________________________ Prof. Loganathan R. Head of the Department

Department of CSE, HKBKCE

II

2011-2012

Acknowledgement
We would like to express our regards and acknowledgement to all those who helped in making this project possible. First and foremost we would take this opportunity to express our heartfelt gratitude to the Chairman Mr. C. M. Ibrahim and the Director Mr. C. M. Faiz Mohammed of our college, HKBKCE. We are also grateful to the Administrator Mr. Abdul Hameed S. A. and the Principal Dr. T. C. Manjunath for providing facilities and untiring zeal, which constantly inspired us towards the attainment of everlasting knowledge throughout the course. We are deeply indebted to the H.O.D Prof. R. Loganathan of Computer Science and Engineering department for the valuable suggestions and constant encouragement provided for the successful completion of the mini project. We would like to thank our guide Ms. Shahzia Siddiqua, Senior Lecturer of Computer Science and Engineering department for the constant guidance for the successful completion of mini project. Finally, we would like to thank all the staff members of Computer Science and Engineering department for their guidance and support .We are also thankful to our family and friends who continue to give us best support. 1HK09CS046 MURALIDHARAN 1HK09CS033 MUZAMMIL BASHA S.J. SAIPREETH

Department of CSE, HKBKCE

III

2011-2012

ABSTRACT
The purpose of this project is to illustrate the simple use of lighting effects on an object showcasing different properties of colours and corresponding changes in the object. The properties can be chosen along with colours red, blue, green and white. The properties are diffuse, ambient, specular, emission and shininess. The other window shows scaling and rotation which can be controlled with the use of cursor keys.

Department of CSE, HKBKCE

IV

2011-2012

TABLE OF CONTENT
Title Page Certificate Acknowledgment Abstract Table of Contents List of Figures Chapter-1 Chapter-2 Introduction Requirement Specification 2.1 2.2 2.3 Chapter-3 User Requirement Specification Hardware and Software Requirements Introduction to the Environment I II III IV V VI 7 7 8 8 8 11 11 11 13 33 34 35 36

Design 3.1 3.2 Libraries Used Working of the Program

Chapter 4 Chapter 5 Chapter 6 Chapter 7 Bibliography

Implementation Snapshots Conclusion Scope for Future Enhancements

Department of CSE, HKBKCE

2011-2012

TABLE OF FIGURES
Fig. 5.1 Cursor position displayed on terminal for Window 1 Fig. 5.2 Cursor position displayed on terminal for Window 2 Fig. 5.3 Window 2 for Scaling & Rotation Fig. 5.3 Light Effects for Window 1 Fig. 5.4 Light Effects for Window 1 33 33 33 33 33

Department of CSE, HKBKCE

VI

2011-2012

Department of CSE, HKBKCE

VII

2011-2012

Multi-Window Light Effects

Introduction

Chapter-1

Introduction

OpenGL is an API (Application Programming Interface) which provides the actual drawing tool through a collection of functions that are called within an application. It suits well for use in computer graphics because of its device independence or portability. It offers a rich and highly usable API for 2D, 3D graphics and image manipulation. Computer graphics is concerned with all aspects of producing pictures or images using a computer. OpenGL is a graphics software system which has become a widely accepted standard for developing graphics applications. it is easy to learn and it possesses most of the characteristics of other popular graphics system. OpenGL is a software interface to graphics hardware. OpenGL is a library of functions for fast 3d rendering. The openGL utility library (GLU) provides many modelling features. It is a standard part of every openGL implementation. It is ideal for 3d visualization but offers little support for creating application user interfaces. OpenGLs main purpose is to render 2D & 3D objects into a frame buffer. These objects are described as sequence of vertices (which define geometric objects) or pixels. (which define images)

Department of CSE, HKBKCE

2011-2012

Multi-Window Light Effects

Requirement Specification

Chapter-2
2.1

Requirement Specification

User Requirement Specification

This software is developed with the following features: A good graphical user interface to make the user comfortable with the software and make his interaction a good experience. To use openGLs capability to plot the graphics. And make it to rotate. Should be a device independent package. the program should be capable to run on any screen resolution. 2.2 Hardware and Software Requirements

The proper functioning of the software requires a minimum hardware and software configuration as listed: Intel pentium III or more powerful processor. 256 MB RAM or more. (512 MB RAM recommended) A GPU powerful enough for fast rendering. Microsoft windows 2000/xp/vista. Or Linux (Ubuntu)

Enough available disk space to store the program and associated libraries (*.lib and *.dll files). A mouse and keyboard as an input devices and necessary drivers installed. 2.3 Introduction to the Environment OpenGL (open graphics library) is a standard specification defining a cross-language, crossplatform API for writing applications that produce 2D and 3D computer graphics. The interface consists of over 250 different function calls which can be used to draw complex threedimensional scenes from simple primitives. Opengl was developed by silicon graphics inc. (SGI) in 1992 and is widely used in cad, virtual reality, scientific visualization, information visualization,

Department of CSE, HKBKCE

2011-2012

Multi-Window Light Effects

Requirement Specification

and flight simulation. It is also used in video games, where it competes with direct3d on microsoft
windows platforms (see direct3D vs. OpenGL). Opengl is managed by the non-profit technology

consortium, the khronos group. At its most basic level opengl is a specification, meaning it is simply a document that describes a set of functions and the precise behaviours that they must perform. From this specification, hardware vendors create implementations libraries of functions created to match the functions stated in the opengl specification, making use of hardware acceleration where possible. Hardware vendors have to meet specific tests to be able to qualify their implementation as an opengl implementation. Opengl serves two main purposes: To hide the complexities of interfacing with different 3D accelerators, by presenting the programmer with a single, uniform api. To hide the differing capabilities of hardware platforms, by requiring that all implementations support the full opengl feature set (using software emulation if necessary). Opengl's basic operation is to accept primitives such as points, lines and polygons, and convert them into pixels. This is done by a graphics pipeline known as the opengl state machine. Most opengl commands either issue primitives to the graphics pipeline, or configure how the pipeline processes these primitives. Prior to the introduction of opengl 2.0, each stage of the pipeline performed a fixed function and was configurable only within tight limits. Opengl 2.0 offers several stages that are fully programmable using GLSL. Opengl is a low-level, procedural api, requiring the programmer to dictate the exact steps required to render a scene. This contrasts with descriptive (aka scene graph or retained mode) apis, where a programmer only needs to describe a scene and can let the library manage the details of rendering it. Opengl's low-level design requires programmers to have a good knowledge of the graphics pipeline, but also gives a certain amount of freedom to implement novel rendering algorithms. Opengl has historically been influential on the development of 3d accelerators, promoting a base level of functionality that is now common in consumer-level hardware:
Department of CSE, HKBKCE

2011-2012

Multi-Window Light Effects

Requirement Specification

A brief description of the process in the graphics pipeline could be Vertex operations, transforming and lighting them depending on their material. Also clipping non visible parts of the scene in order to produce the viewing volume. Rasterisation or conversion of the previous information into pixels. The polygons are represented by the appropriate colour by means of interpolation algorithms. Per-fragment operations, like updating values depending on incoming and previously stored depth values, or colour combinations, among others.lastly, fragments are inserted into the frame
buffer.

Many modern 3D accelerators provide functionality far above this baseline, but these new features are generally enhancements of this basic pipeline rather than radical revisions of it.

Department of CSE, HKBKCE

10

2011-2012

Multi-Window Light Effects

Design

Chapter-3

Design

The project was developed using the C/C++ programming with the following functionalities: 3.1 Libraries Used

GLUT - The OpenGL Utility Toolkit


GLUT is the OpenGL Utility Toolkit, a window system independent toolkit for writing OpenGL programs. It implements a simple windowing application programming interface (API) for OpenGL. GLUT makes it considerably easier to learn about and explore OpenGL programming. GLUT provides a portable API so you can write a single OpenGL program that works across all PC and workstation OS platforms. GLUT is designed for constructing small to medium sized OpenGL programs. While GLUT is well-suited to learning OpenGL and developing simple OpenGL applications, GLUT is not a full-featured toolkit so large applications requiring sophisticated user interfaces are better off using native window system toolkits. GLUT is simple, easy, and small. The GLUT library has both C, C++ (same as C), FORTRAN, and Ada programming bindings. 3.2 Working of the Program

The working of the program can be illustrated by the following abstract algorithm: 1. Initialization Initialize to interact with the window system Initialize the display mode that is double buffer mode and RGB color mode Initialize the window position and the window size Initialize and create the window

Department of CSE, HKBKCE

11

2011-2012

Multi-Window Light Effects

Design

2. Every time the window is resized, the MyReshape function is called to resize the output.

3. Menus and sub-menus are created. Depending on the value returned by the MyMenu function, the suitable operation is performed. 4. Keyboard functions are also initialized. Depending on the value returned by the MyKeyboard function, the suitable operations are performed. 5. The glutIdleFunc() is initialized to continuously make the objects to rotate.
6. The window can be activated by moving the cursor into that particular window. The

movement or position of the cursor, into the window, will be displayed in the terminal.
7. The keyboard functions can be activated when the appropriate key is pressed. The options

and their functions are shown below:

Window 1

d :- Diffuse a :- Ambient s :- Specular e :- Emissive i :- Shininess p :- Light Position r :- Red w :- White g :- Green b :- Blue
12 2011-2012

Department of CSE, HKBKCE

Multi-Window Light Effects

Design

Window 2
Left and Right Arrow keys for Rotation. Up and Down Arrow keys for Scaling.

Department of CSE, HKBKCE

13

2011-2012

Multi-Window Light Effects

Implementation

Chapter-4

Implementation

/*An Interactive Program to create 3d objects*/

#include <GL/glut.h> #include <stdio.h> #include <string.h> #include <math.h> #include <stdlib.h> #include <ctype.h> #define ESC 27 // Dimensions of current window (reshaping is supported). int width = 700; int height = 600;

// Global variables that are set by keystrokes or // mouse movements and used to control the display. unsigned char key = ' '; int colour = -1; // Last key pressed // Colour selection: 0=r, 1=g, 2=b, -1=w.

GLfloat ar = 1.33f; GLfloat xm = 0.5; GLfloat ym = 0.5;


Department of CSE, HKBKCE

// Aspect ratio // X mouse position 0 < xm < 1 // Y mouse position 0 < ym < 1
14 2011-2012

Multi-Window Light Effects

Implementation

// Light properties (controlled by mouse position)

GLfloat l_pos[] = { 5.0, 1.0, 5.0, 1.0 }; GLfloat l_diff[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat l_amb[] = { 0.2f, 0.2f, 0.2f, 1.0 }; GLfloat l_spec[] = { 0.0, 0.0, 0.0, 1.0 };

// Position // Diffuse // Ambient // Specular

// Model properties (controlled by mouse position) GLfloat m_diff[] = { 1.0, 1.0, 1.0, 1.0 }; GLfloat m_spec[] = { 0.0, 0.0, 0.0, 1.0 }; GLfloat m_emit[] = { 0.0, 0.0, 0.0, 1.0 }; GLfloat m_shine[] = { 0.0 }; // Update the value of a property. If the current colour is // 0, 1, or 2, change the corresponding colour component only. // If colour=-1, change all components to the same value. // Diffuse // Specular // Emission // Shininess

GLfloat m_amb[] = { 0.2f, 0.2f, 0.2f, 1.0 }; // Ambient

//for Window 2 #define DIM 100 double altitude[DIM][DIM]; double spin = 0.0, z = 0.0,
Department of CSE, HKBKCE

// Number of lines on each side // Array of heights for each vertex // Amount of spin // Zoom Factor
15 2011-2012

Multi-Window Light Effects maxAlt = 0.0, minAlt = 0.0, red = 1.0, green = 1.0, blue = 1.0; /*GLUquadricObj *qobj;*/ //-----------------SUBROUTINES----------------//Subroutine Declaration... //for window1 void keys (unsigned char thiskey, int x, int y); void help (); void drag (int x, int y); void reshape (int w, int h); void project (void); void report (); void show (GLfloat y, char *name, GLfloat a[], int n); void showstring (GLfloat x, GLfloat y, char *string); void set (GLfloat p[], GLfloat v); // RGB Components

Implementation

//for window 2

Department of CSE, HKBKCE

16

2011-2012

Multi-Window Light Effects

Implementation

void setAltitude(); void pickColor(int a, int b ); void Init(); // Function to determine drawing color // Initialization routine // Determines Projection type

void Reshape(int width, int height);

void keypressed(int key2, int x, int y); // Uses Special Function Keys void drawMyStuff(); void display_win2(); // Window variables int win1, win2; void display(void) // Display routine for both Window 1 and 2 { glClearColor(0.4, 0.4, 0.6, 1.0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if (glutGetWindow() == win1) { // Displaying Window 1 //glColor3f(1.0, 0.0, 0.0); glPushMatrix(); project(); // glFlush(); glPopMatrix(); } else
Department of CSE, HKBKCE

// Basic Drawing Routine

17

2011-2012

Multi-Window Light Effects { // Displaying Window 2 glClearColor(0.5, 0.5, 0.5, 0.0); glShadeModel(GL_FLAT); glPushMatrix(); display_win2(); //calls display function for second window.... glFlush(); glPopMatrix(); } //glFlush(); glutSwapBuffers(); }

Implementation

/*void display_win1(void) // Initial Window 1 display calls the other routine { glPushMatrix(); display(); glPopMatrix(); }*/ // This function can tell which window is being left or entered void which_window(int state) { printf("%s Window %d \n", state == GLUT_LEFT ? "Leaving" : "Entering", glutGetWindow()); } // Simple Mouse Function void mouse(int button, int state, int x, int y)
Department of CSE, HKBKCE

18

2011-2012

Multi-Window Light Effects {

Implementation

printf("button: %d %s %d,%d\n", button, state == GLUT_UP ? "UP" : "down", x, y); } /*void init(void) { // Define first Quadric Object, a solid sphere as a call list. gluQuadricDrawStyle(qobj, GLU_FILL); glNewList(1, GL_COMPILE); //create sphere display list for Object 1 gluSphere(qobj, 1.0, 20, 20); glEndList(); // Create a second Quadric Object, a wireframe sphere gluQuadricDrawStyle(qobj, GLU_LINE); glNewList(2, GL_COMPILE); gluSphere(qobj, 0.5, 10, 10); glEndList(); glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse); glLightfv(GL_LIGHT0, GL_POSITION, light_position); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); glMatrixMode(GL_PROJECTION); gluPerspective( 40.0, 1.0, 1.0, 20.0); glMatrixMode(GL_MODELVIEW); gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.); glTranslatef(0.0, 0.0, -1.0); }*/ //create sphere display list for Object 2

Department of CSE, HKBKCE

19

2011-2012

Multi-Window Light Effects int main(int argc, char **argv) { glutInit(&argc, argv);

Implementation

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); // Create First Window glutInitWindowSize(width, height); win1 = glutCreateWindow("Lighting and Materials. Press 'h' for instructions."); glutEntryFunc(which_window); //glutDisplayFunc(display); glutReshapeFunc(reshape); glutKeyboardFunc(keys); glutMotionFunc(drag); glClearColor(0, 0, 0, 1.0); glutDisplayFunc(display); //glutIdleFunc(display); glEnable(GL_DEPTH_TEST); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); //glutMainLoop(); // Create Second Window setAltitude(); // Initialize heights

glEnable(GL_DEPTH_TEST); glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH ); // Initialize modes


Department of CSE, HKBKCE

20

2011-2012

Multi-Window Light Effects

Implementation

glutInitWindowSize( 550, 550); glutInitWindowPosition( 720, 50); win2 = glutCreateWindow( "Cool Equations"); glutEntryFunc(which_window); //Init(); glutSpecialFunc(keypressed); glutDisplayFunc(display); glutIdleFunc(display); glutReshapeFunc(Reshape); glutMouseFunc(mouse); //Init(); glutMainLoop(); return 0; } //definations for win 2 void setAltitude() { int a, b; for( a = 0; a < DIM; a++) for( b = 0; b < DIM; b++) { // Use some ugly math equation to generate a height value altitude[a][b]= 16*sin(a/8.0)*cos(b/8.0); // Figure out what the extremes in altitude might be maxAlt = maxAlt > altitude[a][b] ? maxAlt : altitude[a][b]; minAlt = minAlt < altitude[a][b] ? minAlt : altitude[a][b]; }
Department of CSE, HKBKCE

/* ANSI C requires main to return int. */

// Initializes heights

21

2011-2012

Multi-Window Light Effects } void pickColor(int a, int b ) { double temp, range; range = maxAlt - minAlt; temp = altitude[a][b]; // Some kind of bizarre function to pick RGB values green = 0.2 + fabs(temp *2/ range); red = 1 + (temp*2/range); blue = 0.2 + cos(temp*2/range); } void Init() { glShadeModel(GL_FLAT); } void Reshape(int width, int height) { glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); // Draw in Perspective rather than Orthographic Projection // Determines Projection type // Initialization routine // Function to determine drawing color

Implementation

glClearColor(0.5, 0.5, 0.5, 0.0);

// Args: (Field_of_View, Aspect_Ratio, Near_Clipping_Plane, Far_Clipping_Plane) gluPerspective(60.0, (float)width / (float)height, 1.00, 2*DIM); glMatrixMode(GL_MODELVIEW); } // Defined Keys:

Department of CSE, HKBKCE

22

2011-2012

Multi-Window Light Effects

Implementation

void keypressed(int key2, int x, int y) // Uses Special Function Keys { if (key2 == GLUT_KEY_LEFT) { spin -= 5; } { spin += 5; } { z += 5; } { z -= 5; } glutPostRedisplay(); } void drawMyStuff() {// Basic Drawing Routine int a, b; glLoadIdentity(); // Specify View Position - (where you are looking.) // Args: ( Eye_X, Eye_Y, Eye_Z, Cntr_X, Cntr_Y, Cntr_Z, Up_X, Up_Y, UpZ) gluLookAt(0.0, DIM/4.0, DIM/2.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0); glTranslatef(0.0, 0.0, (-DIM/2-z) ); // Zoom In and Out glRotatef(spin, 0.0, 1.0, 0.0); // Comple Motion starts here glPushMatrix(); glColor3f(1.0, 1.0, 0.0); glutWireCube(8.0); // Establish a new reference point // Change Drawing color to Yellow // Draw a wire frame Cube glTranslatef(0.0, -35.0, 0.0); // Translate -35 in y-direction // Rotate Basic Surface around Y // Rotate left 5 degrees // Rotate right 5 degrees // Move object away // Move closer // Update the Display if (key2 == GLUT_KEY_RIGHT) if (key2 == GLUT_KEY_UP ) if (key2 == GLUT_KEY_DOWN)

glRotatef(-spin*2, 0.0, 1.0, 0.0); // Rotate axis in opposite direction


Department of CSE, HKBKCE

23

2011-2012

Multi-Window Light Effects glPushMatrix(); glColor3f(1.0, 0.0, 0.0); glTranslatef(20.0, 0.0, 0.0); glutWireSphere(5.0, 8, 6); glPopMatrix(); glPopMatrix(); // End of complex motion for( a=0; a<DIM; a++) { glBegin(GL_LINE_STRIP); for( b=0; b<DIM; b++) { pickColor(a,b); glColor3f(red, green, blue); // Change RGB Values // Choose New Color // Establish yet another reference point // Change color to Red // Translate 20 units in x-direction // Draw Wire Sphere with 5.0 radius // Return to previous reference // Return to first point of reference

Implementation

// Draw Segments in one direction

glVertex3f((a - DIM/2 ), altitude[a][b], (b - DIM/2)); // Draw segment } glEnd(); } for( b=0; b<DIM; b++) { glBegin(GL_LINE_STRIP); for( a = 0; a < DIM; a++) { pickColor(a,b); glColor3f(red, green, blue); // Change RGB Values // Choose New Color // Draw Segments in other direction

glVertex3f((a - DIM/2 ), altitude[a][b], (b - DIM/2)); // Draw segment } glEnd(); } }

Department of CSE, HKBKCE

24

2011-2012

Multi-Window Light Effects

Implementation

void display_win2() { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); // Color and Depth drawMyStuff(); glFlush(); glutSwapBuffers(); // Double Buffering allows for smooth animation } //Win 1 void set (GLfloat p[], GLfloat v) { if (colour >= 0) p[colour] = v; else { int i; for (i = 0; i < 3; i++) p[i] = v; } } // Display a bit-mapped character string. void showstring (GLfloat x, GLfloat y, char *string) { int len, i; glRasterPos2f(x, y); len = (int) strlen(string); for (i = 0; i < len; i++) glutBitmapCharacter(GLUT_BITMAP_9_BY_15, string[i]); }
Department of CSE, HKBKCE

25

2011-2012

Multi-Window Light Effects

Implementation

// Display the value of a property represented as an array with n components. void show (GLfloat y, char *name, GLfloat a[], int n) { char buf[100]; showstring(0.0, y, name); if (n == 1) sprintf(buf, "%8.3f", a[0]); else sprintf(buf, "%8.3f %8.3f %8.3f ", a[0], a[1], a[2]); showstring(0.7f, y, buf); } // Display the values of all lighting parameters.

void report () { char buf[100]; showstring(0.0, 0.0, "Light R G B"); show(-0.1f, "d Diffuse", l_diff, 3); show(-0.2f, "a Ambient", l_amb, 3); show(-0.3f, "s Specular", l_spec, 3); show(-0.4f, "p Position", l_pos, 3); showstring(0.0, -0.6f, "Model R G B"); show(-0.7f, "d Diffuse", m_diff, 3); show(-0.8f, "a Ambient", m_amb, 3); show(-0.9f, "s Specular", m_spec, 3); show(-1.0f, "e Emissive", m_emit, 3);
Department of CSE, HKBKCE

26

2011-2012

Multi-Window Light Effects show(-1.1f, "i Shininess", m_shine, 1); strcpy(buf, ""); switch (colour) { case -1: strcpy(buf, "Colour: white."); break; case 0: strcpy(buf, "Colour: red."); break; case 1: strcpy(buf, "Colour: green."); break; case 2: strcpy(buf, "Colour: blue."); break; } showstring(0.0, -1.3f, buf); strcpy(buf, ""); switch (key) { case 'd': strcpy(buf, "Property: diffuse."); break; case 'a': strcpy(buf, "Property: ambient."); break; case 's':
Department of CSE, HKBKCE

Implementation

27

2011-2012

Multi-Window Light Effects strcpy(buf, "Property: specular."); break; case 'e': strcpy(buf, "Property: emission."); break; case 'i': strcpy(buf, "Property: shininess."); break; case 'p': strcpy(buf, "Property: light position."); break; } showstring(1.5, -1.3f, buf); } // The display function uses the current key to select light and model // properties, then it uses the current mouse position to change those // properties. After the properties have been set, the lights and model // are defined and drawn on the screen, along with parameter values.

Implementation

void project (void) { // Use the mouse position to set values of the specified properties. switch (key) case 'd': set(l_diff, xm); set(m_diff, ym); break;
Department of CSE, HKBKCE

28

2011-2012

Multi-Window Light Effects case 'a': set(l_amb, xm); set(m_amb, ym); break; case 's': set(l_spec, xm); set(m_spec, ym); break; case 'e': set(m_emit, ym); break; case 'i': m_shine[0] = 128.0 * ym; break; case 'p': l_pos[0] = 20.0 * (xm - 0.5f); l_pos[1] = 20.0 * (ym - 0.5f); break; default: break; } glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

Implementation

// Assign the chosen values. glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, m_diff); glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, m_amb);
Department of CSE, HKBKCE

29

2011-2012

Multi-Window Light Effects glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, m_spec);

Implementation

glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, m_shine); glLightfv(GL_LIGHT0, GL_DIFFUSE, l_diff); glLightfv(GL_LIGHT0, GL_AMBIENT, l_amb); glLightfv(GL_LIGHT0, GL_SPECULAR, l_spec); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); // Position the light and then move the model into the viewing volume. glLightfv(GL_LIGHT0, GL_POSITION, l_pos); glTranslatef(-1.0, -1.0, -8.0); // Disable lighting while displaying text.

glDisable(GL_LIGHTING); glPushMatrix(); glTranslatef(0.8f, 0.8f, 0.0); report(); glEnable(GL_LIGHTING); glPopMatrix(); // Display the objects. glPushMatrix(); glRotatef(90.0, -1.0, 0.0, 0.0);
Department of CSE, HKBKCE

30

2011-2012

Multi-Window Light Effects glutSolidCone(0.5, 2.0, 40, 40); glPopMatrix(); glTranslatef(0.0, 2.5, 0.0); glutSolidSphere(0.5, 40,40); // Swap buffers for smooth animation. glutSwapBuffers(); }

Implementation

// Respond to reshape request by changing the viewport and the projection. void reshape (int w, int h) { glViewport(0, 0, w, h); width = w; height = h; ar = (GLfloat) width / (GLfloat) height; glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(30.0, ar, 1.0, 10.0); glutPostRedisplay(); } // Respond to mouse movements by setting xm and ym to values in [0,1]. void drag (int x, int y) { xm = (GLfloat) x / (GLfloat) width; ym = 1.0 - (GLfloat) y / (GLfloat) height; glutPostRedisplay();
Department of CSE, HKBKCE

31

2011-2012

Multi-Window Light Effects } // Display some useful remarks in the Xterm window. void help () { printf("Press a key to select a property.\n");

Implementation

printf("Move the mouse to see the effect of changing the property.\n\n"); printf("Key X motion (light) Y motion (object)\n"); printf(" d printf(" a printf(" s printf(" i printf(" e diffuse ambient specular diffuse\n"); ambient\n"); specular\n"); shininess\n"); emission\n\n");

printf("By default, mouse movement will change all colour components.\n"); printf("To select one colour component:\n"); printf(" Press 'r' for red.\n"); printf(" Press 'g' for green.\n"); printf(" Press 'b' for blue.\n"); printf(" Press 'w' (white) to change all components.\n\n"); } // Respond to a keystroke. Some responses are processed here; the default // action is to record the keystroke and use it in the display callback function. void keys (unsigned char thiskey, int x, int y) { switch (thiskey) {
Department of CSE, HKBKCE

32

2011-2012

Multi-Window Light Effects case ESC: exit(0); case 'h': help(); break; case 'r': break; case 'g': colour = 1; break; case 'b': colour = 2; break; case 'w': colour = -1; break; default: key = thiskey; break; } glutPostRedisplay(); } // Save key value for display() // Change all colours // Change blue values only // Change green values only // Change red values only colour = 0; // Display help in text window

Implementation

Department of CSE, HKBKCE

33

2011-2012

Multi-Window Light Effects

Snapshots

Chapter-5

Snapshots

Fig 5.1 Cursor position displayed on terminal for Window 1

Fig 5.2 Cursor position displayed on terminal for Window 2

Fig 5.3 Window 2 for Scaling & Rotation

Fig 5.4 Light effects for Window 1

Fig 5.6 Light Effects for Window 1

Department of CSE, HKBKCE

34

2011-2012

Multi-Window Light Effects

Conclusion

Chapter-6

Conclusion

The program is successfully implemented as required by user software requirements. The program provides all the functionality required by the user in an optimal way. The program is user friendly and provides the necessary options to the user whenever required. The software is developed with a simple interface.

The main purpose of developing this graphics package was not to develop an unmatchable graphics scene but to develop a one which could perform the most basic operations and during the process aid us in learning about computer graphics and programming. The graphics package has been tested under Windows and has been found to be user friendly providing ease of use and manipulation to the user.

We found designing and developing this graphics package as a very interesting and learning experience. It helped us to learn about computer graphics, design of Graphical User Interfaces (GUI), interface to the user, user interaction handling and screen management. The graphics package has been incorporated with more than the required features that have been detailed in the university syllabi.

Department of CSE, HKBKCE

35

2011-2012

Multi-Window Light Effects

Future Enhancements

Chapter-7

Scope for Future Enhancements

The following are some of the features that are planned to be supported in the future versions of our project. The number of object and colors that are provided for drawing the object purposed can be increased.

Support for more 3d drawings and transformations.


Improve the looks of my project and to reduce the cluttering due to available tools on the screen.

Department of CSE, HKBKCE

36

2011-2012

Bibliography

[1]. Interactive Computer Graphics A Top-Down Approach with OpenGL-Edward Angel,5th edition,Addison-Wesley,2008. [2]. Copmuter Graphics Using OpenGL-F.S Hill,Jr,2nd edition,Pearson Education,2001. [3]. www.opengl.org. [online] www.opengl.org/resources/faq/technical/window.htm . [4].opengl programming guide. http://glprogramming.com. [online] http://glprogramming.com/red/appendixd.html.

Department of CSE, HKBKCE

37

2011-2012