OpenGL Basics. OpenGL – Open Graphics Library What it is a s/w interface to graphics h/w mid-level, device-independent, portable graphics subroutine.

OpenGL Basics

OpenGL – Open Graphics Library

What it is a s/w interface to graphics h/w mid-level, device-independent, portable graphics

subroutine package developed primarily by SGI 2D/3D graphics, lower-level primitives (polygons) does not include low-level I/O management basis for higher-level libraries/toolkits

The camera analogy

OpenGL libraries

GL – gl.h – Opengl32.lib Provides basic commands for graphics drawing

GLU (OpenGL Utility Library) – glu.h – glu32.lib Uses GL commands for performing compound graphics like

viewing orientation and projection specification polygon tessellations, surface rendering etc.

GLUT (OpenGL Utility Toolkit) – glut.h – glut.lib is a window system-independent toolkit for user interaction built on top

of OpenGL and WGL (Windows) or GLX (Linux).

System-specific OpenGl extensions GLX : for X window system (Linux/Unix) WGL: for Windows 95/98/2000/NT AGL : Apple Macintosh system

OpenGL conventions

Functions in OpenGL start with gl Most functions use just gl (e.g., glColor())

Functions starting with glu are utility functions (e.g., gluLookAt()) Note that GLU functions can always be composed

entirely from core GL functions Functions starting with glut are from the

GLUT library.

OpenGL conventions

Function names indicate argument type and number Functions ending with f take floats Functions ending with i take ints Functions ending with b take bytes Functions ending with ub take unsigned bytes Functions that end with v take an array.

Examples glColor3f() takes 3 floats glColor4fv() takes an array of 4 floats

Graphics Pipeline

Step 1: Modeling Transform

Vertices of an object are define in it’s own co-ordinate system (Object Space)

A scene is composed of different objects and some times multiple copy of the same object

Modeling transforms places all the objects in a world co-ordinate system (World Space)

Model Transforms must be specified before specifying the vertices of an object

glRotatef(30, 1, 0, 0); glVertex3d(20, 30, 10);

Basic Modeling Transforms are: Translate : glTranslate{f|d}(x,y,z) Rotate : glRotate{f|d}(,x,y,z) Scale : glScale{f|d}(x,y,z) Object

Space World Space

Instantiate &ModelingTransform

Step 2: Viewing Transform

A model can be viewed from different angles. Viewing Transform specify following information about the

viewer: eye position head up Look at direction

Eye Space

Step 2: Viewing Transform

void gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez, GLdouble centerx, GLdouble centery, GLdouble centerz, GLdouble upx, GLdouble upy, GLdouble upz);

Step 3: Normalize & Clip

Normalize View volume within an unit cube. Remove Primitives that are not in Normalized view volume

Eye Space Clipping Space

• After clipping lighting effects and textures are applied to the primitives

Step 4: Projection

Maps 3D-coordinates to 2D-image coordinates

Par

alle

l P

roje

ctio

n

Per

spec

tive

Pro

ject

ionTypes

Clipping Space

Image Space

Step 4: Projection

Perspective Projection

Step 4: Projection

Perspective Projection

Step 4: Projection

Parallel Projection

Step 5: Rasterization

Projected image (vertices) in image space has fractional x and y co-ordinates values

But raster scan device can only display pixels at integer co-ordinates

Image Space

Screen SpaceRasterization• Some Algorithms:

– DDA (Digital Differential Analyzer

– Brasenham’s Algorithm

– Midpoint Algorithm

Step 6: Viewport Transformation

Maps rasterized 2D images onto graphical device

Screen Space Device Space

Step 6: Viewport Transformation

void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);

gluPerspective(fovy, 1.0, near, far); glViewport(0, 0, 400, 400);

gluPerspective(fovy, 1.0, near, far); glViewport(0, 0, 400, 200);

Graphics Pipeline

GraphicsPrimitives

ObjectSpace

transformmatrix

Modeling Transform

WorldSpace

Eye, lookat,headup

Viewing Transform

EyeSpace

Parallel orPerspectivevolume

Normalize& Clip

ClippingSpace

material,

lights, color

Shading &Texture

viewport

location

Image on Screen

ViewportTransform

DeviceSpace

ImageSpace

Projection

projection

matrix

Image in Internal Buffer

Rasteri-zation

ScreenSpace

Scan

conversion

Primitives

Primitives: Points, Lines & Polygons Each object is specified by a set Vertices

• Grouped together by glBegin & glEnd

glBegin(type)

glVertex*( )

glVertex*( )

…

glEnd( );

• type can have 10

possible values

Primitive Types

GL_POINTS

V0

V1V2

V3

V5

V4

GL_LINE_LOOP

V0

V1 V2

V3

V5

V4

GL_LINE

V0

V1V2

V3

V5

V4

GL_LINE_STRIP

V0

V1V2

V3

V5

V4

GL_POLYGON

V0

V1

V2

V3

V4

Polygon must be:•Simple•No-holes inside•Convex Simple

Non-convex

ComplexConvex

P1

P2

Primitive Types

GL_TRIANGLE

V0

V1

V2

V3

V4

V5

V6

V7V8

GL_QUAD

V0

V1

V2

V3

V4

V5

V6

V7

GL_TRIANGLE_STRIP

V0

V1

V2

V3

V4

V5

Order of Vertex rendering

GL_TRIANGLE_STRIP012, 213, 234, 435

GL_QUAD_STRIP

V0

V1

V2

V3

V4

V5

V6

V7

GL_QUAD_STRIP0132, 2354, 4576

GL_TRIANGLE_FAN

V0

V1

V2

V3

V4

V5

GL_TRIANGLE_FAN012, 023 , 034, 045

Configuring OpenGL in Visual C++

Files Required for GLUT: glut32.dll glut.h glut32.lib

Sample Program

Specify Canvas Color

Must always remember to clear canvas before drawing

glClearColor( r , g , b , α ) specify the color to clear the canvas to should generally set α to be 0 (i. e., fully transparent) this is a state variable, and can be done only once

glClear( GL_ COLOR_ BUFFER_ BIT) actually clears the screen glClear clears such as the depth buffer GL_ DEPTH_ BUFFER_ BIT but we’re not using it right now

Redrawing Window void glFlush(void);

Forces previously issued OpenGL commands to begin execution It returns before the execution ends. glutSwapBuffers() automatically calls glFlush() For single buffer display function should end with this command

void glFinish(void); Forces previously issued OpenGL commands to complete This command doesn’t return until all effects from previous commands

are fully realized.

void glutPostRedisplay(void); Causes the currently registered display function to be called at the

next available opportunity.

Initializing GLUT

Void glutInit( int argc, char **argv) initialize glut, process command line arguments such as

-geometry, -display etc.

void glutInitDisplayMode(unsigned int mode) Mode for later glutCreateWindow() call mode is a bit-wised Ored combination of

Either GLUT_RGBA or GLUT_INDEX Either GLUT_SINGLE or GLUT_DOUBLE One or more GLUT_DEPTH, GLUT_STENCIL, GLUT_ACCUM

buffers default:RGBA & SINGLE

Initializing GLUT

void glutInitWindowPosition(int x, int y) Initial location of window

void glutInitWindowSize(int width, int height) Initial size of window

int glutCreateWindow(char *name) Called after Init, Displaymode, Position and Size calls Window will not appear until glutMainLoop is called Return value is a unique identifier for the window

Event driven approach void glutMainLoop(void);

enters the GLUT event processing loop.

should be called at most once in a GLUT program.

Once called, this routine will never return.

It will call as necessary any callbacks that have been registered.

While (TRUE) {e=getNextEvent();

switch (e) { case (MOUSE_EVENT): call registered MouseFunc break; case (RESIZE_EVENT): call registered ReshapeFunc break; … }

EventQueue

Keyboard Callback

Mouse Callback

Display Callback

Keyboard

Mouse

Display

OS MainLoop

Each application has itsOwn event queue

Callback Functions

void glutDisplayFunc(void (*func) (void)) Specifies the function that’s called whenever

the window is initially opened The content of the window is needed to be redrawn glutPostRedisplay() is explicitly called.

void glutReshapeFunc(void (*func)(int width, int height));

Specifies the function that’s called whenever The window is resized or moved

The function should perform following tasks Call glViewPort(0,0,width, height); // default behavior Redefine projection matrix to match aspect ratio of

image & view port

Callback Functions

void glutKeyboardFunc(

void (* func)(unsigned int key, int x, int y) ); Specifies the function that’s called whenever

a key that generates an ASCII character is pressed. The key callback parameter is the generated ASCII

value. The x and y callback parameters indicate the location

of the mouse when the key was pressed.

Callback Functions void glutMouseFunc(

void (* func)(int button, int state, int x, int y)); Specifies the function that’s called whenever a mouse

button is pressed or released. button callback parameter is one of

GLUT_LEFT_BUTTON GLUT_MIDDLE_BUTTON GLUT_RIGHT_BUTTON

state callback parameter is either GLUT_UP GLUT_DOWN

The x and y callback parameters indicate the location of the mouse when the event occurred.

Animation( Motion = Redraw+Swap )

Animation( Motion = Redraw+Swap )

Animation( Motion = Redraw+Swap )

Transformation in OpenGL

OpenGL uses 3 stacks to maintain transformation matrices:

Model & View transformation matrix stack Projection matrix stack Texture matrix stack

You can load, push and pop the stack The top most matrix from each stack is applied to

all graphics primitive until it is changed

M N

Model-ViewMatrix Stack

ProjectionMatrix Stack

GraphicsPrimitives

(P)

OutputN•M•P

Translation – 2D

(4,5) (7,5)

Y

XBefore Translation

1

*

100

10

01

1

y

x

d

d

y

x

TPPd

dT

y

xP

y

xP

y

x

y

x

Form sHomogeniou

x’ = x + dx y’ = y + dy

(7,1) (10,1)

X

Y

Translation by (3,-4)

Transformations and OpenGL®

Each time an OpenGL transformation M is called the current MODELVIEW matrix C is altered:

Cvv CMvv

glTranslatef(1.5, 0.0, 0.0);glRotatef(45.0, 0.0, 0.0, 1.0);

CTRvv

Note: v is any vertex placed in rendering pipeline v’ is the transformed vertex from v.

Matrix Operation

Thinking About Transformations

As a Global System Objects moves but

coordinates stay the same

Think of transformation in reverse order as they appear in code

As a Local System Objects moves and

coordinates move with it

Think of transformation in same order as they appear in code

There is a World Coordinate System where: All objects are defined Transformations are in World Coordinate space

Two Different Views

Local View Translate Object Then Rotate

Order of Transformation T•R

glLoadIdentity();glMultiMatrixf( T);

glMultiMatrixf( R);

draw_ the_ object( v);v’ = ITRv

Global View Rotate Object

Then Translate

Effect is same, but perception is different

Order of Transformation R•T

glLoadIdentity();glMultiMatrixf( R);

glMultiMatrixf( T);

draw_ the_ object( v);v’ = ITRv

Local View Rotate Object Then Translate

Global View Translate Object

Then Rotate

Effect is same, but perception is different

Thank You