cg labs project final v1

VISVESVARAYA TECHNOLOGICAL UNIVERSITYBELGAUM

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-2012By

Mr. SAIPREETH MURALIDHARAN (1HK09CS046)&

Mr. MUZAMMIL BASHA S.J. (IHK09CS033)Under the guidance of

Mrs. SHAHZIA SIDDIQUALecturer, CSE

HKBKCE, Bangalore

HKBK COLLEGE of ENGINEERINGNagawara, Bangalore – 560 045Email: [email protected]: www.hkbkeducation.org

Department of CSE, HKBKCE I 2011-2012

HKBK COLLEGEofENGINEERING

N a g a w a r a , B e n g a l u r u – 5 6 0 0 4 5

Approved by AICTE & Affiliated to VTU

__________________________________ _____________________________________Ms. Shahzia Siddiqua Prof. Loganathan R.

Guide Head of the Department

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

2011–12. 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 06CSL67–Computer Graphics and Visualization Lab

prescribed for the said Degree.

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 SAIPREETH

MURALIDHARAN

1HK09CS033 MUZAMMIL BASHA S.J.

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 I

Certificate II

Acknowledgment III

Abstract IV

Table of Contents V

List of Figures VI

Chapter-1 Introduction 7

Chapter-2 Requirement Specification 7

2.1 User Requirement Specification 8

2.2 Hardware and Software Requirements 8

2.3 Introduction to the Environment 8

Chapter-3 Design 11

3.1 Libraries Used 11

3.2 Working of the Program 11

Chapter 4 Implementation 13

Chapter 5 Snapshots 33

Chapter 6 Conclusion 34

Chapter 7 Scope for Future Enhancements 35

Bibliography 36

Department of CSE, HKBKCE V 2011-2012

TABLE OF FIGURES

Fig. 5.1 Cursor position displayed on terminal for Window 1 33

Fig. 5.2 Cursor position displayed on terminal for Window 2 33

Fig. 5.3 Window 2 for Scaling & Rotation 33

Fig. 5.3 Light Effects for Window 1 33

Fig. 5.4 Light Effects for Window 1 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.

OpenGL’s 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 7 2011-2012

Multi-Window Light Effects Requirement Specification

Chapter-2 Requirement Specification

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 openGL’s 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, cross-

platform 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 three-

dimensional 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,

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,


http://en.wikipedia.org/wiki/Retained_mode

http://en.wikipedia.org/wiki/Scene_graph

http://en.wikipedia.org/wiki/GLSL

http://www.opengl.org/documentation/specs/version1.1/state.pdf

http://en.wikipedia.org/wiki/Graphics_pipeline

http://en.wikipedia.org/wiki/Khronos_Group

http://en.wikipedia.org/wiki/Comparison_of_OpenGL_and_Direct3D

http://en.wikipedia.org/wiki/Microsoft_Windows

http://en.wikipedia.org/wiki/Microsoft_Windows

http://en.wikipedia.org/wiki/Direct3D

http://en.wikipedia.org/wiki/Video_games

http://en.wikipedia.org/wiki/Flight_simulator

http://en.wikipedia.org/wiki/Virtual_reality

http://en.wikipedia.org/wiki/Computer-aided_design

http://en.wikipedia.org/wiki/Silicon_Graphics

http://en.wikipedia.org/wiki/Geometric_primitive

http://en.wikipedia.org/wiki/3D_computer_graphics

http://en.wikipedia.org/wiki/2D_computer_graphics


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:

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.


http://en.wikipedia.org/wiki/Framebuffer

http://en.wikipedia.org/wiki/Framebuffer

http://en.wikipedia.org/wiki/Rasterisation

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

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


Multi-Window Light Effects Design

3. Menu’s and sub-menu’s 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

Window 2

Left and Right Arrow keys for Rotation.

Up and Down Arrow keys for Scaling.


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 = ' '; // Last key pressed

int colour = -1; // Colour selection: 0=r, 1=g, 2=b, -1=w.

GLfloat ar = 1.33f; // Aspect ratio

GLfloat xm = 0.5; // X mouse position 0 < xm < 1

GLfloat ym = 0.5; // Y mouse position 0 < ym < 1



// Light properties (controlled by mouse position)

GLfloat l_pos[] = { 5.0, 1.0, 5.0, 1.0 }; // Position

GLfloat l_diff[] = { 1.0, 1.0, 1.0, 1.0 }; // Diffuse

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

GLfloat l_spec[] = { 0.0, 0.0, 0.0, 1.0 }; // Specular

// Model properties (controlled by mouse position)

GLfloat m_diff[] = { 1.0, 1.0, 1.0, 1.0 }; // Diffuse

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

GLfloat m_spec[] = { 0.0, 0.0, 0.0, 1.0 }; // Specular

GLfloat m_emit[] = { 0.0, 0.0, 0.0, 1.0 }; // Emission

GLfloat m_shine[] = { 0.0 }; // Shininess

// 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.

//for Window 2

#define DIM 100 // Number of lines on each side

double altitude[DIM][DIM]; // Array of heights for each vertex

double spin = 0.0, // Amount of spin

z = 0.0, // Zoom Factor



maxAlt = 0.0,

minAlt = 0.0,

red = 1.0, green = 1.0, blue = 1.0; // RGB Components

/*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);

//for window 2



void setAltitude();

void pickColor(int a, int b ); // Function to determine drawing color

void Init(); // Initialization routine

void Reshape(int width, int height); // Determines Projection type

void keypressed(int key2, int x, int y); // Uses Special Function Keys

void drawMyStuff(); // Basic Drawing Routine

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



{ // 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();

}

/*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)



{

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); //create sphere display list for Object 2

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);

}*/



int main(int argc, char **argv)

{

glutInit(&argc, argv);

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_LIGHT0);

//glutMainLoop();

// Create Second Window

setAltitude(); // Initialize heights


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



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; /* ANSI C requires main to return int. */

}

//definations for win 2

void setAltitude() { // Initializes heights

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];

}



}

void pickColor(int a, int b ) { // Function to determine drawing color

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() { // Initialization routine

glClearColor(0.5, 0.5, 0.5, 0.0);

glShadeModel(GL_FLAT);

}

void Reshape(int width, int height) { // Determines Projection type

glViewport(0, 0, width, height);


glLoadIdentity();

// Draw in Perspective rather than Orthographic Projection

// Args: (Field_of_View, Aspect_Ratio, Near_Clipping_Plane, Far_Clipping_Plane)

gluPerspective(60.0, (float)width / (float)height, 1.00, 2*DIM);


}

// Defined Keys:



void keypressed(int key2, int x, int y) // Uses Special Function Keys

{ if (key2 == GLUT_KEY_LEFT)

{ spin -= 5; } // Rotate left 5 degrees

if (key2 == GLUT_KEY_RIGHT)

{ spin += 5; } // Rotate right 5 degrees

if (key2 == GLUT_KEY_UP )

{ z += 5; } // Move object away

if (key2 == GLUT_KEY_DOWN)

{ z -= 5; } // Move closer

glutPostRedisplay(); // Update the Display

}

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); // Rotate Basic Surface around Y

// Comple Motion starts here

glPushMatrix(); // Establish a new reference point

glTranslatef(0.0, -35.0, 0.0); // Translate -35 in y-direction

glColor3f(1.0, 1.0, 0.0); // Change Drawing color to Yellow

glutWireCube(8.0); // Draw a wire frame Cube

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



glPushMatrix(); // Establish yet another reference point

glColor3f(1.0, 0.0, 0.0); // Change color to Red

glTranslatef(20.0, 0.0, 0.0); // Translate 20 units in x-direction

glutWireSphere(5.0, 8, 6); // Draw Wire Sphere with 5.0 radius

glPopMatrix(); // Return to previous reference

glPopMatrix(); // Return to first point of reference

// End of complex motion

for( a=0; a<DIM; a++) {

glBegin(GL_LINE_STRIP); // Draw Segments in one direction

for( b=0; b<DIM; b++) {

pickColor(a,b); // Change RGB Values

glColor3f(red, green, blue); // Choose New Color

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

}

glEnd();

}

for( b=0; b<DIM; b++) {

glBegin(GL_LINE_STRIP); // Draw Segments in other direction

for( a = 0; a < DIM; a++) {

pickColor(a,b); // Change RGB Values

glColor3f(red, green, blue); // Choose New Color

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

}

glEnd();

}

}



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]);

}



// 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);



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':



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.

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;



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);

// Assign the chosen values.

glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, m_diff);

glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, m_amb);



glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, m_spec);

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);


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();


glPopMatrix();

// Display the objects.

glPushMatrix();

glRotatef(90.0, -1.0, 0.0, 0.0);



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();

}

// 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;


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;




}

// Display some useful remarks in the Xterm window.

void help () {

printf("Press a key to select a property.\n");

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 diffuse diffuse\n");

printf(" a ambient ambient\n");

printf(" s specular specular\n");

printf(" i shininess\n");

printf(" e 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) {



case ESC:

exit(0);

case 'h': // Display help in text window

help();

break;

case 'r': // Change red values only

colour = 0;

break;

case 'g': // Change green values only

colour = 1;

break;

case 'b': // Change blue values only

colour = 2;

break;

case 'w': // Change all colours

colour = -1;

break;

default: // Save key value for display()

key = thiskey;

break;

}


}


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

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.


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.


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.


cg labs project final v1

Documents

window light

create

3d accelerators

args

graphics pipeline

computer graphics

temp2range

requirement