CG Labs Project Final v1

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
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
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.
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
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
VI
2011-2012
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)
2011-2012
Requirement Specification
Chapter-2
2.1
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,
2011-2012
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:
2011-2012
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.
10
2011-2012
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
11
2011-2012
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
Design
Window 2
Left and Right Arrow keys for Rotation. Up and Down Arrow keys for Scaling.
13
2011-2012
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;

// Aspect ratio // X mouse position 0 < xm < 1 // Y mouse position 0 < ym < 1
14 2011-2012
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,
// 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
16
2011-2012
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
// 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)
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
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

20
2011-2012
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]; }
/* 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:
22
2011-2012
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

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(); } }
24
2011-2012
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]); }
25
2011-2012
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);
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':
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;
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);
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);
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();
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) {
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
33
2011-2012
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
34
2011-2012
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.
35
2011-2012
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.
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.
37
2011-2012

CG Labs Project Final v1

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

CG Labs Project Final v1

Uploaded by

Copyright:

Available Formats

VISVESVARAYA TECHNOLOGICAL UNIVERSITY

A PROJECT REPORT On MULTI-WINDOW LIGHT EFFECTS

Computer Science and Engineering

Mrs. SHAHZIA SIDDIQUA

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

Department of Computer Science and Engineering

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

in partial fulfillment for

Department of CSE, HKBKCE

Department of CSE, HKBKCE

Department of CSE, HKBKCE

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

Department of CSE, HKBKCE

Department of CSE, HKBKCE

Multi-Window Light Effects

Department of CSE, HKBKCE

Multi-Window Light Effects

User Requirement Specification

Department of CSE, HKBKCE

Multi-Window Light Effects

Multi-Window Light Effects

Department of CSE, HKBKCE

Multi-Window Light Effects

GLUT - The OpenGL Utility Toolkit

Department of CSE, HKBKCE

Multi-Window Light Effects

and their functions are shown below:

Department of CSE, HKBKCE

Multi-Window Light Effects

Department of CSE, HKBKCE

Multi-Window Light Effects

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

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

Multi-Window Light Effects

// Light properties (controlled by mouse position)

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

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

Department of CSE, HKBKCE

Multi-Window Light Effects

void Reshape(int width, int height);

// Basic Drawing Routine

Multi-Window Light Effects {

Department of CSE, HKBKCE

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

Multi-Window Light Effects

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

glClearColor(0.5, 0.5, 0.5, 0.0);

Department of CSE, HKBKCE

Multi-Window Light Effects

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

// Draw Segments in one direction

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

Department of CSE, HKBKCE

Multi-Window Light Effects

Multi-Window Light Effects

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

Department of CSE, HKBKCE

Multi-Window Light Effects

Fig 5.1 Cursor position displayed on terminal for Window 1

Fig 5.2 Cursor position displayed on terminal for Window 2

/An Interactive Program to create 3d objects/