Project

1

VISVESVARAYA TECHNOLOGICAL UNIVERSITY,

BELGAUM

A PROJECT REPORT ON

Effect of lighting on solids

Submitted in partial fulfillment of the requirements of the Award of degree of

BACHELOR OF ENGINEERING IN

COMPUTER SCIENCE & ENGINEERING By

K R ANAND 4VV11CS019

SHANTHARAJU N 4VV11CS051

UNDER THE GUIDANCE OF

Mrs. Sunita B.K., M.Tech

Assistant Professor, Department of Computer Science & Engineering

VVCE, Mysore

2012-2013

DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

VIDYAVARDHAKA COLLEGE OF ENGINEERING

MYSORE

Vidyavardhaka College of Engineering

Gokulum 3rd Stage,

Mysore-570002

Department of Computer Science and Engineering

2

This is to certify that the Project entitled Lighting effect on solids is a bonafide

work carried out by K R Anand (4VV11CS019) and Shantharaju N (4VV11CS051) of

6th semester Computer Science and Engineering as prescribed by Visvesvaraya

Technological University Belgaum, during the academic year 2012-2013.

It is certified that all the suggestions and corrections indicated for the internal

assessment have been incorporated in the report deposited in the department library.

The project report has been approved as it satisfies the requirements in respect of project

work prescribed for the said degree.

Signature of Guide Signature of HOD Signature of Principal

------------------------- ------------------------ ----------------------------

Mrs. Sunita B.K Prof. Dr.Yuvaraju B.N Dr.B.Sadashive Gowda

(Asst. Prof., Dept CSE) (HOD, Dept CSE) (Principal, VVCE, Mysore)

Name of the examiners

1)

2)

3)

3

ACKNOWLEDGEMENT

If words are considered as the tokens of acknowledges, then the words play the

heralding role of expressing my gratitude.

With proud gratitude we thank God Almighty for all the blessings showered on me and

for completing my project successfully.

We owe our gratitude to The Principal, Dr. B Sadashive Gowda for his whole hearted

support and for his kind permission to undergo the project.

We wish to express our deepest gratitude to Prof. Dr. Yuvaraju B.N, Head of

Department, Computer Science and Engineering, VVCE, for her profound alacrity

in our project and his valuable suggestions.

We wish to enunciate our special thanks to our paradigmatic and relevant internal

guide Mrs. Sunita B.K, Assistant Professor in Computer Science and Engineering,

VVCE who gave us throughout our project period with their valuable suggestions and

for devoting their precious time in making this project a success.

In the end, we are anxious to offer our sincere thanks to our family members and

friend for their valuable suggestions, encouragement and unwavering supports.

K R Anand

Shantharaju N

4

TABLE OF CONTENT

5

CHAPTER - 1

INTRODUCTION

1.1 Overview of Computer Graphics

Computer Graphics is concerned with all aspects of producing pictures or images using

computer. These are intentionally fashioned to achieve some visual effects. Computer

Graphics also refers to the tools used to make such pictures. There are both hardware and

software tools.

Hardware tools include video monitors and printers that display graphics, and input

devices like a mouse or track ball. Software tools are editors, compilers, debugger found

in any programming environment.

Interactive computer graphics is the most important means of producing pictures since the

invention of photography and television. A picture is worth ten thousand words.

Interactive computer graphics thus permits extensive, high-bandwidth user-computer

interaction.

Computer graphics concerns with the pictorial synthesis of real or imaginary objects from

their computer based models, where as the related field of image processing treats the

converse process, the analysis of scenes, or the reconstruction of models of 2D or 3D

objects from their pictures.

Computer Graphics has become a powerful tool for the rapid and economical production

of pictures. There is virtually no area in which Graphical displays cannot be used to some

advantage so it is not surprising to find the use of Computer Graphics so widespread.

1.2 History of Computer Graphics

This field began humbly almost 50 years ago, with display of a few lines on a cathode ray

tube. William fetter was credited with coining the term Computer Graphics in 1960, to

describe his work at Boeng. One of the first displays of computer animation was future

world (1976), which included an animation of a human face and hand-produced by

Carmull and Fred Parkle at the University of Utah.

There are several international conferences and journals where the most significant results

in computer-graphics are published. Among them are the SIGGRAPH and Euro graphics

6

conferences and the association for computing machinery (ACM) transaction on Graphics

journals.

1.3 Application of Computer Graphics

The applications of computer graphics are many and varied; however, we can divide them

into four major areas as described:

1.3.1 Display of information

Classical graphics techniques arose as a medium to convey information among people.

Although spoken and written languages serve a similar purpose, the human visual system

is unrivaled both as a processor of data and as a pattern recognizer. Today, architects,

mechanical designers, generate the same type of information and drafts people-using

computer based drafting systems.

For centuries, cartographers have developed maps to display celestial and geographical

information, which were crucial for navigators. Now, maps can be developed and

manipulated in real time over internet.

Medical imaging poses interesting and important data analysis problems. Modern

imaging technologies such as computed tomography (CT), magnetic resonance imaging

(MRI), ultrasound, and positron emission tomography (PET) generate three-dimensional

data that must be subjected t algorithmic manipulation to provide useful information.

Supercomputers now allow researchers in many areas to solve previously intractable

problems. In fields such as fluid flow, molecular biology, and mathematics, images

generated by conversion of data to geometric entities that can be displayed have yielded

new insights into complex processes.

1.3.2 Design

Professions such as engineering and architecture are concerned with design. Starting

with a set of specifications, engineers and architects seek a cost effective and esthetic

solution that satisfies the specifications.

Design is an iterative process. Design problems are either over determined, such that

they possess no solution that satisfies all criteria, much less an optimal solution, or

underdetermined, such that they have multiple solutions that satisfy the design criteria.

Thus, the designer works iteratively by generating a possible design, testing it, and then

using the results as the basis for exploring other solutions.

7

The use of interactive graphical tools in computer aided design (CAD) pervades fields

including as architectures, mechanical engineering, the design of very-large scale

integrated (VLSI) circuits, and the creation of characters for animations. In all these

applications, the graphics are used in a number of distinct ways.

1.3.3 Simulation and Animation

In real time, graphics systems are used as simulators. One of the most important uses

has been in the training of pilots. Graphical flight simulators have proved to increase

safety and to reduce training expenses.

Games and educational software for home computers are almost as impressive. The

simulator can be used for designing the robot, planning its path, and simulating its

behavior in complex environments.

Computer graphics is being widely used for animation in the television, motion picture,

and advertising industries. Computers at a cost less than that of movies made with

traditional hand-animation techniques can now make entire animated movies.

The field of virtual reality (VR) has opened many new horizons. A human viewer can be

equipped with a display headset that allows him to see separate images with his right and

left eye, which gives the effect of stereoscopic vision.

1.3.4 User interface

Our interaction with computers has become dominated by a visual paradigm that

includes windows, icons, menus, and a pointing device, such as mouse. From a user's

perspective, windowing systems such as X Window System, Microsoft Windows, and the

Macintosh OS X differ only in details.

More recently, millions of people have become Internet users. Their access is through

graphical network browsers, such as Firefox and Internet Explorer that use these same

interface tools. We are so accustomed to this style of interface that we often forget that

we are working with computer graphics.

Now a days even school children are comfortable with interactive graphics techniques,

such as the desktop metaphor for window manipulation and menu and icons selection

with mouse. Graphics based user interfaces have made productive users of neophytes, and

the desk without its graphics computer is increasingly rare.

8

1.4 Statement of the Project

Our statement of the project is "Effect of lighting on solids". The concerning work is

achieved by using computer graphics and its standard functions defined in

OpenGL package using Microsoft visual C++.

1.5 Objective of the Project

The aim of our project is to develop a program, which shows the effect of lighting on

solids.

The main mode of input or interaction with the user is through the mouse.

1.6 Organization of the Report

Chapter 1 introduces the computer graphics and its applications.

Chapter 2 contains the basic concepts and principle involved in OpenGL.

Chapter 3 deals with Basic Concepts of a lighting.

Chapter 4 Deals with design and implementation and function related to the project.

Chapter 5 contains the snapshots and the result regarding project.

Chapter 6 concludes the project and mentions the future scope.

9

CHAPTER - 2

INTRODUCTION TO OPENGL

2.1 Introduction

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.

OpenGL is not a programming language it is an API (Application Programming

Interface). The interface consists of many different function calls which can be used for

building application programs.

OpenGL is widely used in CAD, virtual reality, scientific visualization, information

visualization, and flight simulation.

OpenGL is portable to many platforms (windows, MAC, UNIX, LINUX) and callable

from many programming languages (C/C++, JAVA, PEARL). OpenGL is primarily

concerned with modeling and rendering operations such as, to specify geometric

primitives (lines, pixels, polygons...), apply geometric transformations and specify

camera light, color, texture information etc.

All functions in OpenGL library are device independent, many operations (windowing,

I/O etc.) are not included in basic core library, and so different auxiliary libraries are

10

developed for features not available in OpenGL. OpenGL libraries are OpenGL:

GL (lib GL) and GLU (lib GLU). These are windows native implementation (OpenGL32)

and Mesa3D: free ware implementation for LINUX. GLUT: OpenGL utility tool kit (lib

glut) the GLUT library is responsible for window and menu management, mouse and

keyboard interactions.

Graphics libraries are GLUI: GLUT based user interface library (lib glui) -It controls

OpenGL applications such as buttons, check boxes, radio buttons etc.

Most of our application will be designed to access OpenGL directly through functions in

three libraries. Functions in the main GL (or OpenGL in windows) library have names

that begin with the letters gl and are stored in a library usually referred to as GL (or

OpenGL in windows).

The second is the OpenGL Utility Library (GLU). This library uses only GL functions but

contains code for creating common objects and simplifying viewing. All functions in

GLU can be created from the core GL library but application programmers prefer not to

write the code repeatedly. The GLU library is available in all OpenGL implementations;

functions in the GLU library begin with letters glu.

To interface with the window system and to get input from external devices into our

programs, we need at least one more library. For each major window system there is a

system specific library that provides the "glue" between the window system and OpenGL.

For the X window system, this library is called GLX, for windows, it is wgl, and for the

Macintosh, it is agl.

Rather than using a different library for each system, we use a readily available library

called the OpenGL Utility Toolkit (GLUT), which provides the minimum functionality

that should be expected in any modern windowing system.

Figure 2.2 shows the organization of the libraries for an X Window System environment.

11

For this window system, GLUT will use GLX and the X libraries. The application

program, however, can use only GLUT functions and thus can be recompiled with the

GLUT library for other window systems.

OpenGL makes heavy use of macros to increase code readability and avoid the use of

magic numbers. Thus strings such as GL_FILL and GL_POINTS are defined in header

files. In most implementations, one of the include lines

#include

Or

#include

is sufficient to read in glut.h, gl.h, and glu.h.

2.2 Why OpenGL

The intention of this chapter is to give you basic concepts in OpenGL. OpenGL is a

device and operating system independent library for 3D-graphics and rendering. OpenGL

was originally developed by Silicon Graphics Inc (SGI) for use on their high end graphics

workstations. Since then, OpenGL has become a widely accepted standard with

implementations on many operating system and hardware platforms including Windows

NT and Windows X operating systems.

The purpose of the OpenGL library is to render two and three- dimensional objects into

frame buffer. OpenGL is a library of high-quality three-dimensional graphics and

rendering functions. The library's device- and platform-independence make it a library of

choice for developing portable graphical applications.

OpenGL drawings are constructed from primitives; primitives are simple items such as

lines or polygons, which in turn are composed of vertices.

The OpenGL Library assembles primitives from vertices while taking into account a

variety of settings, such as color, lighting, and texture. Primitives are then processed in

accordance with transformations, clipping settings, and other parameters; at the end of the

rasterization, process is pixel data deposited into a frame buffer.

Because of high visual quality and performance, any visual computing application

requiring maximum performance-from 3D animation to CAD to visual simulation-can

12

exploit high-quality, high-performance OpenGL capabilities. These capabilities allow

developers in diverse markets such as broadcasting, CAD/CAM/CAE, entertainment,

medical imaging, and virtual reality to produce and display incredibly compelling 2D and

3D graphics.

2.3 Advantages of Using OpenGL

Industry standard: An independent consortium, the OpenGL Architecture Review

Board, guides the OpenGL specification. With broad industry support, OpenGL is the

only truly open, vendor-neutral, multiplatform graphics standard.

Stable: OpenGL implementations have been available for more than seven years on a

wide variety of platforms. Additions to the specification are well controlled, and proposed

updates are announced in time for developers to adopt changes. Backward compatibility

requirements ensure that existing applications do not become obsolete.

Reliable and portable: All OpenGL applications produce consistent visual display

results on any OpenGL API-compliant hardware, regardless of operating system or

windowing system.

Evolving: Because of its thorough and forward-looking design, OpenGL allows new

hardware innovations to be accessible through the API via the OpenGL extension

mechanism. In this way, innovations appear in the API in a timely fashion, letting

application developers and hardware vendors incorporate new features into their normal

product release cycles.

13

CHAPTER - 3

BASIC CONCEPTS OF LIGHTING

OpenGL approximates light and lighting as if light can be broken into red, green, and

blue components. Thus, the color of light sources is characterized by the amount of red,

green, and blue light they emit, and the material of surfaces is characterized by the

percentage of the incoming red, green, and blue components that is reflected in various

directions. The OpenGL lighting equations are just an approximation but one that works

fairly well and can be computed relatively quickly. If you desire a more accurate (or just

different) lighting model, you have to do your own calculations in software. Such

software can be enormously complex, as a few hours of reading any optics textbook

should convince you.

In the OpenGL lighting model, the light in a scene comes from several light sources that

can be individually turned on and off. Some light comes from a particular direction or

position, and some light is generally scattered about the scene. For example, when you

turn on a light bulb in a room, most of the light comes from the bulb, but some light

comes after bouncing off one, two, three, or more walls. This bounced light (called

ambient) is assumed to be so scattered that there is no way to tell its original direction, but

it disappears if a particular light source is turned off.

Finally, there might be a general ambient light in the scene that comes from no particular

source, as if it had been scattered so many times that its original source is impossible to

determine.

In the OpenGL model, the light sources have an effect only when there are surfaces that

absorb and reflect light. Each surface is assumed to be composed of a material with

various properties. A material might emit its own light (like headlights on an automobile),

14

it might scatter some incoming light in all directions, and it might reflect some portion of

the incoming light in a preferential direction like a mirror or other shiny surface.

The OpenGL lighting model considers the lighting to be divided into four independent

components: emissive, ambient, diffuse, and specular. All four components are computed

independently and then added together.

3.1 Ambient, Diffuse, and Specular Light

3.1.1 Ambient

Ambient illumination is light that's been scattered so much by the environment that its

direction is impossible to determine - it seems to come from all directions. Backlighting

in a room has a large ambient component, since most of the light that reaches your eye

has first bounced off many surfaces. A spotlight outdoors has a tiny ambient component;

most of the light travels in the same direction, and since you're outdoors, very little of the

light reaches your eye after bouncing off other objects. When ambient light strikes a

surface, it's scattered equally in all directions.

3.1.2 Diffuse

The diffuse component is the light that comes from one direction, so it's brighter if it

comes squarely down on a surface than if it barely glances off the surface. Once it hits a

surface, however, it's scattered equally in all directions, so it appears equally bright, no

matter where the eye is located. Any light coming from a particular position or direction

probably has a diffuse component.

3.1.3 Specular

Finally, specular light comes from a particular direction, and it tends to bounce off the

surface in a preferred direction. A well-collimated laser beam bouncing off a high-quality

mirror produces almost 100 percent specular reflection. Shiny metal or plastic has a high

specular component, and chalk or carpet has almost none. You can think of specularity as

shininess.

15

3.2 Coding

3.2.1 Light Sources

Although a light source delivers a single distribution of frequencies, the ambient, diffuse,

and specular components might be different. For example, if you have a white light in a

room with red walls, the scattered light tends to be red, although the light directly striking

objects is white.

OpenGL allows you to set the red, green, and blue values for each component of light

independently. Light sources have a number of properties, such as color, position, and

direction. The following sections explain how to control these properties and what the

resulting light looks like. There can be up to 8 source points.

The command used to specify all properties of lights is glLight*(); it takes three

arguments: to identify the light whose property is being specified, the property, and the

desired value for that property.

void glLight{if}(GLenum light, GLenum pname, TYPEparam);

void glLight{if}v(GLenum light, GLenum pname, TYPE *param);

Table 5-1: Default Values for pname Parameter of glLight*()

Parameter Name Default Value Meaning

GL_AMBIENT (0.0, 0.0, 0.0,

1.0)

ambient RGBA intensity of light

GL_DIFFUSE (1.0, 1.0, 1.0,

1.0)

diffuse RGBA intensity of light

GL_SPECULAR (1.0, 1.0, 1.0,

1.0)

specular RGBA intensity of light

16

GL_POSITION (0.0, 0.0, 1.0,

0.0)

(x, y, z, w) position of light

GL_SPOT_DIRECTION (0.0, 0.0, -1.0) (x, y, z) direction of spotlight

GL_SPOT_EXPONENT 0.0 spotlight exponent

GL_SPOT_CUTOFF 180.0 spotlight cutoff angle

3.2.2 Color

OpenGL allows you to associate three different color-related parameters -

GL_AMBIENT, GL_DIFFUSE, and GL_SPECULAR - with any particular light. The

GL_AMBIENT parameter refers to the RGBA intensity of the ambient light that a

particular light source adds to the scene. As you can see in Table 5-1, by default there is

no ambient light since GL_AMBIENT is (0.0, 0.0, 0.0, 1.0). If this program had specified

blue ambient light as

GLfloat light_ambient[] = { 0.0, 0.0, 1.0, 1.0};

glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);

3.2.3 Material Properties

This section describes how to define the material properties of the objects in the scene:

the ambient, diffuse, and specular colors, the shininess, and the color of any emitted light.

Most of the material properties are conceptually similar to ones you've already used to

create light sources. The mechanism for setting them is similar, except that the command

used is called glMaterial*().

void glMaterial{if}(GLenum face, GLenum pname, TYPEparam);

void glMaterial{if}v(GLenum face, GLenum pname, TYPE *param);

Specifies a current material property for use in lighting calculations. face can be

GL_FRONT, GL_BACK, or GL_FRONT_AND_BACK to indicate which face of the

17

object the material should be applied to. The particular material property being set is

identified by pname and the desired values for that property are given by param, which is

either a pointer to a group of values (if the vector version is used) or the actual value (if

the nonvector version is used). The nonvector version works only for setting

GL_SHININESS. The possible values for pname are shown in Table 5-3. Note that

GL_AMBIENT_AND_DIFFUSE allows you to set both the ambient and diffuse material

colors simultaneously to the same RGBA value.

Table 5-3 : Default Values for pname Parameter of glMaterial*()

Parameter Name Default Value Meaning

GL_AMBIENT (0.2, 0.2, 0.2,

1.0)

ambient color of material

GL_DIFFUSE (0.8, 0.8, 0.8,

1.0)

diffuse color of material

GL_AMBIENT_AND_DIFFUSE ambient and diffuse color of

material

GL_SPECULAR (0.0, 0.0, 0.0,

1.0)

specular color of material

GL_SHININESS 0.0 specular exponent

GL_EMISSION (0.0, 0.0, 0.0,

1.0)

emissive color of material

GL_COLOR_INDEXES (0,1,1) ambient, diffuse, and specular color

indices

3.2.4 Diffuse and Ambient Reflection

The GL_DIFFUSE and GL_AMBIENT parameters set with glMaterial*() affect the

color of the diffuse and ambient light reflected by an object. Diffuse reflectance plays the

most important role in determining what you perceive the color of an object to be. It's

affected by the color of the incident diffuse light and the angle of the incident light

relative to the normal direction. (It's most intense where the incident light falls

perpendicular to the surface.) The position of the viewpoint doesn't affect diffuse

reflectance at all.

18

Ambient reflectance affects the overall color of the object. Because diffuse reflectance is

brightest where an object is directly illuminated, ambient reflectance is most noticeable

where an object receives no direct illumination. An object's total ambient reflectance is

affected by the global ambient light and ambient light from individual light sources. Like

diffuse reflectance, ambient reflectance isn't affected by the position of the viewpoint.

For real-world objects, diffuse and ambient reflectance are normally the same color. For

this reason, OpenGL provides you with a convenient way of assigning the same value to

both simultaneously with glMaterial*():

GLfloat mat_amb_diff[] = { 0.1, 0.5, 0.8, 1.0 };

glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE,

mat_amb_diff);

3.2.5 Specular Reflection

Specular reflection from an object produces highlights. Unlike ambient and diffuse

reflection, the amount of specular reflection seen by a viewer does depend on the location

of the viewpoint - it's brightest along the direct angle of reflection. To see this, imagine

looking at a metallic ball outdoors in the sunlight. As you move your head, the highlight

created by the sunlight moves with you to some extent. However, if you move your head

too much, you lose the highlight entirely.

OpenGL allows you to set the effect that the material has on reflected light (with

GL_SPECULAR) and control the size and brightness of the highlight (with

GL_SHININESS). You can assign a number in the range of [0.0, 128.0] to

GL_SHININESS - the higher the value, the smaller and brighter (more focused) the

highlight. E.g.:

GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };

GLfloat low_shininess[] = { 5.0 };

glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);

glMaterialfv(GL_FRONT, GL_SHININESS, low_shininess);

3.2.6 Emission

By specifying an RGBA color for GL_EMISSION, you can make an object appear to be

giving off light of that color. Since most real-world objects (except lights) don't emit

19

light, you'll probably use this feature mostly to simulate lamps and other light sources in a

scene.

GLfloat mat_emission[] = {0.3, 0.2, 0.2, 0.0}; glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);

20

4. Implementation

4.1 Algorithm

main()

{

Initialize Graphics mode

Initialize Window size

Create window

Myinit Func callback

Reshape Func callback

Display Func callback

Mouse Func callback

Keyboard Func callback

}

Display()

{

Call FrontScreen

Rotate light source according to input

Switch objects

MAIN_SCREEN

TORUS

TEAPOT

DOD

TET

ISO

Loop Back

}

21

4.2 Functions Used

4.2.1 glutMotionFunc, glutPassiveMotionFunc

glutMotionFunc and glutPassiveMotionFunc set the motion and passive motion

callbacks respectively for the current window.

Usage

void glutMotionFunc(void (*func)(int x, int y));

void glutPassiveMotionFunc(void (*func)(int x, int y));

Description

glutMotionFunc and glutPassiveMotionFunc set the motion and passive motion callback

respectively for the current window. The motion callback for a window is called when the

mouse moves within the window while one or more mouse buttons are pressed. The

passive motion callback for a window is called when the mouse moves within the window

while no mouse buttons are pressed.

The x and y callback parameters indicate the mouse location in window relative

coordinates.

Passing NULL to glutMotionFunc or glutPassiveMotionFunc disables the generation of

the mouse or passive motion callback respectively.

22

4.2.2 gluPerspective

It set up a perspective projection matrix C Specification void gluPerspective(GLdouble

fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar);

Parameters

fovy

Specifies the field of view angle, in degrees, in the y direction.

aspect

Specifies the aspect ratio that determines the field of view in the x direction.

The aspect ratio is the ratio of x (width) to y (height).

zNear

Specifies the distance from the viewer to the near clipping plane

(always positive).

zFar

Specifies the distance from the viewer to the far clipping plane

(always positive).

Description

gluPerspective specifies a viewing frustum into the world coordinate system.

In general, the aspect ratio in gluPerspective should match the aspect ratio

of the associated viewport. For example,

aspect = 2.0

means the viewer's angle of view is twice as wide in x as it is in y.

If the viewport is twice as wide as it is tall, it displays the image without distortion.

23

The matrix generated by gluPerspective is multipled by the current matrix, just as if

glMultMatrix were called with the generated matrix. To load the perspective matrix onto

the current matrix stack instead, precede the call to gluPerspective with a call to

glLoadIdentity.

24

CHAPTER 7

RESULTS

7.1 Snapshots

25

26

27

28

29

6.CONCLUSION

It has been challenging and rewarding for us to do this project